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       result = Dali::PixelData::New(arg1,arg2,arg3,arg4,arg5,arg6);
23979     } catch (std::out_of_range& e) {
23980       {
23981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23982       };
23983     } catch (std::exception& e) {
23984       {
23985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23986       };
23987     } catch (Dali::DaliException e) {
23988       {
23989         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23990       };
23991     } catch (...) {
23992       {
23993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23994       };
23995     }
23996   }
23997
23998   jresult = new Dali::PixelData((const Dali::PixelData &)result);
23999
24000
24001   return jresult;
24002 }
24003
24004
24005 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_0() {
24006   void * jresult ;
24007   Dali::PixelData *result = 0 ;
24008
24009   {
24010     try {
24011       result = (Dali::PixelData *)new Dali::PixelData();
24012     } catch (std::out_of_range& e) {
24013       {
24014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24015       };
24016     } catch (std::exception& e) {
24017       {
24018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24019       };
24020     } catch (Dali::DaliException e) {
24021       {
24022         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24023       };
24024     } catch (...) {
24025       {
24026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24027       };
24028     }
24029   }
24030
24031   jresult = (void *)result;
24032   return jresult;
24033 }
24034
24035
24036 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelData(void * jarg1) {
24037   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
24038
24039   arg1 = (Dali::PixelData *)jarg1;
24040   {
24041     try {
24042       delete arg1;
24043     } catch (std::out_of_range& e) {
24044       {
24045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24046       };
24047     } catch (std::exception& e) {
24048       {
24049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24050       };
24051     } catch (Dali::DaliException e) {
24052       {
24053         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24054       };
24055     } catch (...) {
24056       {
24057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24058       };
24059     }
24060   }
24061
24062 }
24063
24064
24065 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_1(void * jarg1) {
24066   void * jresult ;
24067   Dali::PixelData *arg1 = 0 ;
24068   Dali::PixelData *result = 0 ;
24069
24070   arg1 = (Dali::PixelData *)jarg1;
24071   if (!arg1) {
24072     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
24073     return 0;
24074   }
24075   {
24076     try {
24077       result = (Dali::PixelData *)new Dali::PixelData((Dali::PixelData const &)*arg1);
24078     } catch (std::out_of_range& e) {
24079       {
24080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24081       };
24082     } catch (std::exception& e) {
24083       {
24084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24085       };
24086     } catch (Dali::DaliException e) {
24087       {
24088         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24089       };
24090     } catch (...) {
24091       {
24092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24093       };
24094     }
24095   }
24096
24097   jresult = (void *)result;
24098   return jresult;
24099 }
24100
24101
24102 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_Assign(void * jarg1, void * jarg2) {
24103   void * jresult ;
24104   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
24105   Dali::PixelData *arg2 = 0 ;
24106   Dali::PixelData *result = 0 ;
24107
24108   arg1 = (Dali::PixelData *)jarg1;
24109   arg2 = (Dali::PixelData *)jarg2;
24110   if (!arg2) {
24111     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
24112     return 0;
24113   }
24114   {
24115     try {
24116       result = (Dali::PixelData *) &(arg1)->operator =((Dali::PixelData const &)*arg2);
24117     } catch (std::out_of_range& e) {
24118       {
24119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24120       };
24121     } catch (std::exception& e) {
24122       {
24123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24124       };
24125     } catch (Dali::DaliException e) {
24126       {
24127         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24128       };
24129     } catch (...) {
24130       {
24131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24132       };
24133     }
24134   }
24135
24136   jresult = (void *)result;
24137   return jresult;
24138 }
24139
24140
24141 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetWidth(void * jarg1) {
24142   unsigned int jresult ;
24143   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
24144   unsigned int result;
24145
24146   arg1 = (Dali::PixelData *)jarg1;
24147   {
24148     try {
24149       result = (unsigned int)((Dali::PixelData const *)arg1)->GetWidth();
24150     } catch (std::out_of_range& e) {
24151       {
24152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24153       };
24154     } catch (std::exception& e) {
24155       {
24156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24157       };
24158     } catch (Dali::DaliException e) {
24159       {
24160         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24161       };
24162     } catch (...) {
24163       {
24164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24165       };
24166     }
24167   }
24168
24169   jresult = result;
24170   return jresult;
24171 }
24172
24173
24174 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetHeight(void * jarg1) {
24175   unsigned int jresult ;
24176   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
24177   unsigned int result;
24178
24179   arg1 = (Dali::PixelData *)jarg1;
24180   {
24181     try {
24182       result = (unsigned int)((Dali::PixelData const *)arg1)->GetHeight();
24183     } catch (std::out_of_range& e) {
24184       {
24185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24186       };
24187     } catch (std::exception& e) {
24188       {
24189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24190       };
24191     } catch (Dali::DaliException e) {
24192       {
24193         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24194       };
24195     } catch (...) {
24196       {
24197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24198       };
24199     }
24200   }
24201
24202   jresult = result;
24203   return jresult;
24204 }
24205
24206
24207 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelData_GetPixelFormat(void * jarg1) {
24208   int jresult ;
24209   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
24210   Dali::Pixel::Format result;
24211
24212   arg1 = (Dali::PixelData *)jarg1;
24213   {
24214     try {
24215       result = (Dali::Pixel::Format)((Dali::PixelData const *)arg1)->GetPixelFormat();
24216     } catch (std::out_of_range& e) {
24217       {
24218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24219       };
24220     } catch (std::exception& e) {
24221       {
24222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24223       };
24224     } catch (Dali::DaliException e) {
24225       {
24226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24227       };
24228     } catch (...) {
24229       {
24230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24231       };
24232     }
24233   }
24234
24235   jresult = (int)result;
24236   return jresult;
24237 }
24238
24239
24240 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_X_get() {
24241   unsigned int jresult ;
24242   unsigned int result;
24243
24244   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_X;
24245   jresult = result;
24246   return jresult;
24247 }
24248
24249
24250 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_X_get() {
24251   unsigned int jresult ;
24252   unsigned int result;
24253
24254   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_X;
24255   jresult = result;
24256   return jresult;
24257 }
24258
24259
24260 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Y_get() {
24261   unsigned int jresult ;
24262   unsigned int result;
24263
24264   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Y;
24265   jresult = result;
24266   return jresult;
24267 }
24268
24269
24270 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Y_get() {
24271   unsigned int jresult ;
24272   unsigned int result;
24273
24274   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Y;
24275   jresult = result;
24276   return jresult;
24277 }
24278
24279
24280 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Z_get() {
24281   unsigned int jresult ;
24282   unsigned int result;
24283
24284   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Z;
24285   jresult = result;
24286   return jresult;
24287 }
24288
24289
24290 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Z_get() {
24291   unsigned int jresult ;
24292   unsigned int result;
24293
24294   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Z;
24295   jresult = result;
24296   return jresult;
24297 }
24298
24299
24300 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_0(int jarg1, int jarg2, unsigned int jarg3, unsigned int jarg4) {
24301   void * jresult ;
24302   Dali::TextureType::Type arg1 ;
24303   Dali::Pixel::Format arg2 ;
24304   unsigned int arg3 ;
24305   unsigned int arg4 ;
24306   Dali::Texture result;
24307
24308   arg1 = (Dali::TextureType::Type)jarg1;
24309   arg2 = (Dali::Pixel::Format)jarg2;
24310   arg3 = (unsigned int)jarg3;
24311   arg4 = (unsigned int)jarg4;
24312   {
24313     try {
24314       result = Dali::Texture::New(arg1,arg2,arg3,arg4);
24315     } catch (std::out_of_range& e) {
24316       {
24317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24318       };
24319     } catch (std::exception& e) {
24320       {
24321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24322       };
24323     } catch (Dali::DaliException e) {
24324       {
24325         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24326       };
24327     } catch (...) {
24328       {
24329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24330       };
24331     }
24332   }
24333
24334   jresult = new Dali::Texture((const Dali::Texture &)result);
24335   return jresult;
24336 }
24337
24338
24339 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_1(void * jarg1) {
24340   void * jresult ;
24341   NativeImageInterface *arg1 = 0 ;
24342   Dali::Texture result;
24343
24344   arg1 = (NativeImageInterface *)jarg1;
24345   if (!arg1) {
24346     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
24347     return 0;
24348   }
24349   {
24350     try {
24351       result = Dali::Texture::New(*arg1);
24352     } catch (std::out_of_range& e) {
24353       {
24354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24355       };
24356     } catch (std::exception& e) {
24357       {
24358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24359       };
24360     } catch (Dali::DaliException e) {
24361       {
24362         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24363       };
24364     } catch (...) {
24365       {
24366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24367       };
24368     }
24369   }
24370
24371   jresult = new Dali::Texture((const Dali::Texture &)result);
24372   return jresult;
24373 }
24374
24375
24376 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_0() {
24377   void * jresult ;
24378   Dali::Texture *result = 0 ;
24379
24380   {
24381     try {
24382       result = (Dali::Texture *)new Dali::Texture();
24383     } catch (std::out_of_range& e) {
24384       {
24385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24386       };
24387     } catch (std::exception& e) {
24388       {
24389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24390       };
24391     } catch (Dali::DaliException e) {
24392       {
24393         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24394       };
24395     } catch (...) {
24396       {
24397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24398       };
24399     }
24400   }
24401
24402   jresult = (void *)result;
24403   return jresult;
24404 }
24405
24406
24407 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Texture(void * jarg1) {
24408   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24409
24410   arg1 = (Dali::Texture *)jarg1;
24411   {
24412     try {
24413       delete arg1;
24414     } catch (std::out_of_range& e) {
24415       {
24416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24417       };
24418     } catch (std::exception& e) {
24419       {
24420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24421       };
24422     } catch (Dali::DaliException e) {
24423       {
24424         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24425       };
24426     } catch (...) {
24427       {
24428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24429       };
24430     }
24431   }
24432
24433 }
24434
24435
24436 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_1(void * jarg1) {
24437   void * jresult ;
24438   Dali::Texture *arg1 = 0 ;
24439   Dali::Texture *result = 0 ;
24440
24441   arg1 = (Dali::Texture *)jarg1;
24442   if (!arg1) {
24443     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
24444     return 0;
24445   }
24446   {
24447     try {
24448       result = (Dali::Texture *)new Dali::Texture((Dali::Texture const &)*arg1);
24449     } catch (std::out_of_range& e) {
24450       {
24451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24452       };
24453     } catch (std::exception& e) {
24454       {
24455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24456       };
24457     } catch (Dali::DaliException e) {
24458       {
24459         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24460       };
24461     } catch (...) {
24462       {
24463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24464       };
24465     }
24466   }
24467
24468   jresult = (void *)result;
24469   return jresult;
24470 }
24471
24472
24473 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_DownCast(void * jarg1) {
24474   void * jresult ;
24475   Dali::BaseHandle arg1 ;
24476   Dali::BaseHandle *argp1 ;
24477   Dali::Texture result;
24478
24479   argp1 = (Dali::BaseHandle *)jarg1;
24480   if (!argp1) {
24481     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24482     return 0;
24483   }
24484   arg1 = *argp1;
24485   {
24486     try {
24487       result = Dali::Texture::DownCast(arg1);
24488     } catch (std::out_of_range& e) {
24489       {
24490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24491       };
24492     } catch (std::exception& e) {
24493       {
24494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24495       };
24496     } catch (Dali::DaliException e) {
24497       {
24498         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24499       };
24500     } catch (...) {
24501       {
24502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24503       };
24504     }
24505   }
24506
24507   jresult = new Dali::Texture((const Dali::Texture &)result);
24508   return jresult;
24509 }
24510
24511
24512 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_Assign(void * jarg1, void * jarg2) {
24513   void * jresult ;
24514   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24515   Dali::Texture *arg2 = 0 ;
24516   Dali::Texture *result = 0 ;
24517
24518   arg1 = (Dali::Texture *)jarg1;
24519   arg2 = (Dali::Texture *)jarg2;
24520   if (!arg2) {
24521     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
24522     return 0;
24523   }
24524   {
24525     try {
24526       result = (Dali::Texture *) &(arg1)->operator =((Dali::Texture const &)*arg2);
24527     } catch (std::out_of_range& e) {
24528       {
24529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24530       };
24531     } catch (std::exception& e) {
24532       {
24533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24534       };
24535     } catch (Dali::DaliException e) {
24536       {
24537         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24538       };
24539     } catch (...) {
24540       {
24541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24542       };
24543     }
24544   }
24545
24546   jresult = (void *)result;
24547   return jresult;
24548 }
24549
24550
24551 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_Upload__SWIG_0(void * jarg1, void * jarg2) {
24552   unsigned int jresult ;
24553   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24554   Dali::PixelData arg2 ;
24555   Dali::PixelData *argp2 ;
24556   bool result;
24557
24558   arg1 = (Dali::Texture *)jarg1;
24559   argp2 = (Dali::PixelData *)jarg2;
24560   if (!argp2) {
24561     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
24562     return 0;
24563   }
24564   arg2 = *argp2;
24565   {
24566     try {
24567       result = (bool)(arg1)->Upload(arg2);
24568     } catch (std::out_of_range& e) {
24569       {
24570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24571       };
24572     } catch (std::exception& e) {
24573       {
24574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24575       };
24576     } catch (Dali::DaliException e) {
24577       {
24578         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24579       };
24580     } catch (...) {
24581       {
24582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24583       };
24584     }
24585   }
24586
24587   jresult = result;
24588   return jresult;
24589 }
24590
24591
24592 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) {
24593   unsigned int jresult ;
24594   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24595   Dali::PixelData arg2 ;
24596   unsigned int arg3 ;
24597   unsigned int arg4 ;
24598   unsigned int arg5 ;
24599   unsigned int arg6 ;
24600   unsigned int arg7 ;
24601   unsigned int arg8 ;
24602   Dali::PixelData *argp2 ;
24603   bool result;
24604
24605   arg1 = (Dali::Texture *)jarg1;
24606   argp2 = (Dali::PixelData *)jarg2;
24607   if (!argp2) {
24608     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
24609     return 0;
24610   }
24611   arg2 = *argp2;
24612   arg3 = (unsigned int)jarg3;
24613   arg4 = (unsigned int)jarg4;
24614   arg5 = (unsigned int)jarg5;
24615   arg6 = (unsigned int)jarg6;
24616   arg7 = (unsigned int)jarg7;
24617   arg8 = (unsigned int)jarg8;
24618   {
24619     try {
24620       result = (bool)(arg1)->Upload(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
24621     } catch (std::out_of_range& e) {
24622       {
24623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24624       };
24625     } catch (std::exception& e) {
24626       {
24627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24628       };
24629     } catch (Dali::DaliException e) {
24630       {
24631         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24632       };
24633     } catch (...) {
24634       {
24635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24636       };
24637     }
24638   }
24639
24640   jresult = result;
24641   return jresult;
24642 }
24643
24644
24645 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Texture_GenerateMipmaps(void * jarg1) {
24646   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24647
24648   arg1 = (Dali::Texture *)jarg1;
24649   {
24650     try {
24651       (arg1)->GenerateMipmaps();
24652     } catch (std::out_of_range& e) {
24653       {
24654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24655       };
24656     } catch (std::exception& e) {
24657       {
24658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24659       };
24660     } catch (Dali::DaliException e) {
24661       {
24662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24663       };
24664     } catch (...) {
24665       {
24666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24667       };
24668     }
24669   }
24670
24671 }
24672
24673
24674 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetWidth(void * jarg1) {
24675   unsigned int jresult ;
24676   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24677   unsigned int result;
24678
24679   arg1 = (Dali::Texture *)jarg1;
24680   {
24681     try {
24682       result = (unsigned int)((Dali::Texture const *)arg1)->GetWidth();
24683     } catch (std::out_of_range& e) {
24684       {
24685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24686       };
24687     } catch (std::exception& e) {
24688       {
24689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24690       };
24691     } catch (Dali::DaliException e) {
24692       {
24693         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24694       };
24695     } catch (...) {
24696       {
24697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24698       };
24699     }
24700   }
24701
24702   jresult = result;
24703   return jresult;
24704 }
24705
24706
24707 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetHeight(void * jarg1) {
24708   unsigned int jresult ;
24709   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24710   unsigned int result;
24711
24712   arg1 = (Dali::Texture *)jarg1;
24713   {
24714     try {
24715       result = (unsigned int)((Dali::Texture const *)arg1)->GetHeight();
24716     } catch (std::out_of_range& e) {
24717       {
24718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24719       };
24720     } catch (std::exception& e) {
24721       {
24722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24723       };
24724     } catch (Dali::DaliException e) {
24725       {
24726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24727       };
24728     } catch (...) {
24729       {
24730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24731       };
24732     }
24733   }
24734
24735   jresult = result;
24736   return jresult;
24737 }
24738
24739
24740 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_New() {
24741   void * jresult ;
24742   Dali::Sampler result;
24743
24744   {
24745     try {
24746       result = Dali::Sampler::New();
24747     } catch (std::out_of_range& e) {
24748       {
24749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24750       };
24751     } catch (std::exception& e) {
24752       {
24753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24754       };
24755     } catch (Dali::DaliException e) {
24756       {
24757         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24758       };
24759     } catch (...) {
24760       {
24761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24762       };
24763     }
24764   }
24765
24766   jresult = new Dali::Sampler((const Dali::Sampler &)result);
24767   return jresult;
24768 }
24769
24770
24771 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_0() {
24772   void * jresult ;
24773   Dali::Sampler *result = 0 ;
24774
24775   {
24776     try {
24777       result = (Dali::Sampler *)new Dali::Sampler();
24778     } catch (std::out_of_range& e) {
24779       {
24780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24781       };
24782     } catch (std::exception& e) {
24783       {
24784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24785       };
24786     } catch (Dali::DaliException e) {
24787       {
24788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24789       };
24790     } catch (...) {
24791       {
24792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24793       };
24794     }
24795   }
24796
24797   jresult = (void *)result;
24798   return jresult;
24799 }
24800
24801
24802 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Sampler(void * jarg1) {
24803   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24804
24805   arg1 = (Dali::Sampler *)jarg1;
24806   {
24807     try {
24808       delete arg1;
24809     } catch (std::out_of_range& e) {
24810       {
24811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24812       };
24813     } catch (std::exception& e) {
24814       {
24815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24816       };
24817     } catch (Dali::DaliException e) {
24818       {
24819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24820       };
24821     } catch (...) {
24822       {
24823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24824       };
24825     }
24826   }
24827
24828 }
24829
24830
24831 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_1(void * jarg1) {
24832   void * jresult ;
24833   Dali::Sampler *arg1 = 0 ;
24834   Dali::Sampler *result = 0 ;
24835
24836   arg1 = (Dali::Sampler *)jarg1;
24837   if (!arg1) {
24838     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
24839     return 0;
24840   }
24841   {
24842     try {
24843       result = (Dali::Sampler *)new Dali::Sampler((Dali::Sampler const &)*arg1);
24844     } catch (std::out_of_range& e) {
24845       {
24846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24847       };
24848     } catch (std::exception& e) {
24849       {
24850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24851       };
24852     } catch (Dali::DaliException e) {
24853       {
24854         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24855       };
24856     } catch (...) {
24857       {
24858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24859       };
24860     }
24861   }
24862
24863   jresult = (void *)result;
24864   return jresult;
24865 }
24866
24867
24868 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_DownCast(void * jarg1) {
24869   void * jresult ;
24870   Dali::BaseHandle arg1 ;
24871   Dali::BaseHandle *argp1 ;
24872   Dali::Sampler result;
24873
24874   argp1 = (Dali::BaseHandle *)jarg1;
24875   if (!argp1) {
24876     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24877     return 0;
24878   }
24879   arg1 = *argp1;
24880   {
24881     try {
24882       result = Dali::Sampler::DownCast(arg1);
24883     } catch (std::out_of_range& e) {
24884       {
24885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24886       };
24887     } catch (std::exception& e) {
24888       {
24889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24890       };
24891     } catch (Dali::DaliException e) {
24892       {
24893         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24894       };
24895     } catch (...) {
24896       {
24897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24898       };
24899     }
24900   }
24901
24902   jresult = new Dali::Sampler((const Dali::Sampler &)result);
24903   return jresult;
24904 }
24905
24906
24907 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_Assign(void * jarg1, void * jarg2) {
24908   void * jresult ;
24909   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24910   Dali::Sampler *arg2 = 0 ;
24911   Dali::Sampler *result = 0 ;
24912
24913   arg1 = (Dali::Sampler *)jarg1;
24914   arg2 = (Dali::Sampler *)jarg2;
24915   if (!arg2) {
24916     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
24917     return 0;
24918   }
24919   {
24920     try {
24921       result = (Dali::Sampler *) &(arg1)->operator =((Dali::Sampler const &)*arg2);
24922     } catch (std::out_of_range& e) {
24923       {
24924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24925       };
24926     } catch (std::exception& e) {
24927       {
24928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24929       };
24930     } catch (Dali::DaliException e) {
24931       {
24932         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24933       };
24934     } catch (...) {
24935       {
24936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24937       };
24938     }
24939   }
24940
24941   jresult = (void *)result;
24942   return jresult;
24943 }
24944
24945
24946 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetFilterMode(void * jarg1, int jarg2, int jarg3) {
24947   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24948   Dali::FilterMode::Type arg2 ;
24949   Dali::FilterMode::Type arg3 ;
24950
24951   arg1 = (Dali::Sampler *)jarg1;
24952   arg2 = (Dali::FilterMode::Type)jarg2;
24953   arg3 = (Dali::FilterMode::Type)jarg3;
24954   {
24955     try {
24956       (arg1)->SetFilterMode(arg2,arg3);
24957     } catch (std::out_of_range& e) {
24958       {
24959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24960       };
24961     } catch (std::exception& e) {
24962       {
24963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24964       };
24965     } catch (Dali::DaliException e) {
24966       {
24967         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24968       };
24969     } catch (...) {
24970       {
24971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24972       };
24973     }
24974   }
24975
24976 }
24977
24978
24979 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_0(void * jarg1, int jarg2, int jarg3) {
24980   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24981   Dali::WrapMode::Type arg2 ;
24982   Dali::WrapMode::Type arg3 ;
24983
24984   arg1 = (Dali::Sampler *)jarg1;
24985   arg2 = (Dali::WrapMode::Type)jarg2;
24986   arg3 = (Dali::WrapMode::Type)jarg3;
24987   {
24988     try {
24989       (arg1)->SetWrapMode(arg2,arg3);
24990     } catch (std::out_of_range& e) {
24991       {
24992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24993       };
24994     } catch (std::exception& e) {
24995       {
24996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24997       };
24998     } catch (Dali::DaliException e) {
24999       {
25000         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25001       };
25002     } catch (...) {
25003       {
25004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25005       };
25006     }
25007   }
25008
25009 }
25010
25011
25012 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_1(void * jarg1, int jarg2, int jarg3, int jarg4) {
25013   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
25014   Dali::WrapMode::Type arg2 ;
25015   Dali::WrapMode::Type arg3 ;
25016   Dali::WrapMode::Type arg4 ;
25017
25018   arg1 = (Dali::Sampler *)jarg1;
25019   arg2 = (Dali::WrapMode::Type)jarg2;
25020   arg3 = (Dali::WrapMode::Type)jarg3;
25021   arg4 = (Dali::WrapMode::Type)jarg4;
25022   {
25023     try {
25024       (arg1)->SetWrapMode(arg2,arg3,arg4);
25025     } catch (std::out_of_range& e) {
25026       {
25027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25028       };
25029     } catch (std::exception& e) {
25030       {
25031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25032       };
25033     } catch (Dali::DaliException e) {
25034       {
25035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25036       };
25037     } catch (...) {
25038       {
25039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25040       };
25041     }
25042   }
25043
25044 }
25045
25046
25047 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_New() {
25048   void * jresult ;
25049   Dali::TextureSet result;
25050
25051   {
25052     try {
25053       result = Dali::TextureSet::New();
25054     } catch (std::out_of_range& e) {
25055       {
25056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25057       };
25058     } catch (std::exception& e) {
25059       {
25060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25061       };
25062     } catch (Dali::DaliException e) {
25063       {
25064         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25065       };
25066     } catch (...) {
25067       {
25068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25069       };
25070     }
25071   }
25072
25073   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
25074   return jresult;
25075 }
25076
25077
25078 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_0() {
25079   void * jresult ;
25080   Dali::TextureSet *result = 0 ;
25081
25082   {
25083     try {
25084       result = (Dali::TextureSet *)new Dali::TextureSet();
25085     } catch (std::out_of_range& e) {
25086       {
25087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25088       };
25089     } catch (std::exception& e) {
25090       {
25091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25092       };
25093     } catch (Dali::DaliException e) {
25094       {
25095         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25096       };
25097     } catch (...) {
25098       {
25099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25100       };
25101     }
25102   }
25103
25104   jresult = (void *)result;
25105   return jresult;
25106 }
25107
25108
25109 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextureSet(void * jarg1) {
25110   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25111
25112   arg1 = (Dali::TextureSet *)jarg1;
25113   {
25114     try {
25115       delete arg1;
25116     } catch (std::out_of_range& e) {
25117       {
25118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25119       };
25120     } catch (std::exception& e) {
25121       {
25122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25123       };
25124     } catch (Dali::DaliException e) {
25125       {
25126         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25127       };
25128     } catch (...) {
25129       {
25130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25131       };
25132     }
25133   }
25134
25135 }
25136
25137
25138 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_1(void * jarg1) {
25139   void * jresult ;
25140   Dali::TextureSet *arg1 = 0 ;
25141   Dali::TextureSet *result = 0 ;
25142
25143   arg1 = (Dali::TextureSet *)jarg1;
25144   if (!arg1) {
25145     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
25146     return 0;
25147   }
25148   {
25149     try {
25150       result = (Dali::TextureSet *)new Dali::TextureSet((Dali::TextureSet const &)*arg1);
25151     } catch (std::out_of_range& e) {
25152       {
25153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25154       };
25155     } catch (std::exception& e) {
25156       {
25157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25158       };
25159     } catch (Dali::DaliException e) {
25160       {
25161         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25162       };
25163     } catch (...) {
25164       {
25165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25166       };
25167     }
25168   }
25169
25170   jresult = (void *)result;
25171   return jresult;
25172 }
25173
25174
25175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_DownCast(void * jarg1) {
25176   void * jresult ;
25177   Dali::BaseHandle arg1 ;
25178   Dali::BaseHandle *argp1 ;
25179   Dali::TextureSet result;
25180
25181   argp1 = (Dali::BaseHandle *)jarg1;
25182   if (!argp1) {
25183     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
25184     return 0;
25185   }
25186   arg1 = *argp1;
25187   {
25188     try {
25189       result = Dali::TextureSet::DownCast(arg1);
25190     } catch (std::out_of_range& e) {
25191       {
25192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25193       };
25194     } catch (std::exception& e) {
25195       {
25196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25197       };
25198     } catch (Dali::DaliException e) {
25199       {
25200         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25201       };
25202     } catch (...) {
25203       {
25204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25205       };
25206     }
25207   }
25208
25209   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
25210   return jresult;
25211 }
25212
25213
25214 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_Assign(void * jarg1, void * jarg2) {
25215   void * jresult ;
25216   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25217   Dali::TextureSet *arg2 = 0 ;
25218   Dali::TextureSet *result = 0 ;
25219
25220   arg1 = (Dali::TextureSet *)jarg1;
25221   arg2 = (Dali::TextureSet *)jarg2;
25222   if (!arg2) {
25223     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
25224     return 0;
25225   }
25226   {
25227     try {
25228       result = (Dali::TextureSet *) &(arg1)->operator =((Dali::TextureSet const &)*arg2);
25229     } catch (std::out_of_range& e) {
25230       {
25231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25232       };
25233     } catch (std::exception& e) {
25234       {
25235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25236       };
25237     } catch (Dali::DaliException e) {
25238       {
25239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25240       };
25241     } catch (...) {
25242       {
25243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25244       };
25245     }
25246   }
25247
25248   jresult = (void *)result;
25249   return jresult;
25250 }
25251
25252
25253 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetTexture(void * jarg1, unsigned long jarg2, void * jarg3) {
25254   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25255   size_t arg2 ;
25256   Dali::Texture arg3 ;
25257   Dali::Texture *argp3 ;
25258
25259   arg1 = (Dali::TextureSet *)jarg1;
25260   arg2 = (size_t)jarg2;
25261   argp3 = (Dali::Texture *)jarg3;
25262   if (!argp3) {
25263     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Texture", 0);
25264     return ;
25265   }
25266   arg3 = *argp3;
25267   {
25268     try {
25269       (arg1)->SetTexture(arg2,arg3);
25270     } catch (std::out_of_range& e) {
25271       {
25272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25273       };
25274     } catch (std::exception& e) {
25275       {
25276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25277       };
25278     } catch (Dali::DaliException e) {
25279       {
25280         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25281       };
25282     } catch (...) {
25283       {
25284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25285       };
25286     }
25287   }
25288
25289 }
25290
25291
25292 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetTexture(void * jarg1, unsigned long jarg2) {
25293   void * jresult ;
25294   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25295   size_t arg2 ;
25296   Dali::Texture result;
25297
25298   arg1 = (Dali::TextureSet *)jarg1;
25299   arg2 = (size_t)jarg2;
25300   {
25301     try {
25302       result = ((Dali::TextureSet const *)arg1)->GetTexture(arg2);
25303     } catch (std::out_of_range& e) {
25304       {
25305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25306       };
25307     } catch (std::exception& e) {
25308       {
25309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25310       };
25311     } catch (Dali::DaliException e) {
25312       {
25313         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25314       };
25315     } catch (...) {
25316       {
25317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25318       };
25319     }
25320   }
25321
25322   jresult = new Dali::Texture((const Dali::Texture &)result);
25323   return jresult;
25324 }
25325
25326
25327 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetSampler(void * jarg1, unsigned long jarg2, void * jarg3) {
25328   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25329   size_t arg2 ;
25330   Dali::Sampler arg3 ;
25331   Dali::Sampler *argp3 ;
25332
25333   arg1 = (Dali::TextureSet *)jarg1;
25334   arg2 = (size_t)jarg2;
25335   argp3 = (Dali::Sampler *)jarg3;
25336   if (!argp3) {
25337     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Sampler", 0);
25338     return ;
25339   }
25340   arg3 = *argp3;
25341   {
25342     try {
25343       (arg1)->SetSampler(arg2,arg3);
25344     } catch (std::out_of_range& e) {
25345       {
25346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25347       };
25348     } catch (std::exception& e) {
25349       {
25350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25351       };
25352     } catch (Dali::DaliException e) {
25353       {
25354         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25355       };
25356     } catch (...) {
25357       {
25358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25359       };
25360     }
25361   }
25362
25363 }
25364
25365
25366 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetSampler(void * jarg1, unsigned long jarg2) {
25367   void * jresult ;
25368   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25369   size_t arg2 ;
25370   Dali::Sampler result;
25371
25372   arg1 = (Dali::TextureSet *)jarg1;
25373   arg2 = (size_t)jarg2;
25374   {
25375     try {
25376       result = ((Dali::TextureSet const *)arg1)->GetSampler(arg2);
25377     } catch (std::out_of_range& e) {
25378       {
25379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25380       };
25381     } catch (std::exception& e) {
25382       {
25383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25384       };
25385     } catch (Dali::DaliException e) {
25386       {
25387         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25388       };
25389     } catch (...) {
25390       {
25391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25392       };
25393     }
25394   }
25395
25396   jresult = new Dali::Sampler((const Dali::Sampler &)result);
25397   return jresult;
25398 }
25399
25400
25401 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TextureSet_GetTextureCount(void * jarg1) {
25402   unsigned long jresult ;
25403   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25404   size_t result;
25405
25406   arg1 = (Dali::TextureSet *)jarg1;
25407   {
25408     try {
25409       result = ((Dali::TextureSet const *)arg1)->GetTextureCount();
25410     } catch (std::out_of_range& e) {
25411       {
25412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25413       };
25414     } catch (std::exception& e) {
25415       {
25416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25417       };
25418     } catch (Dali::DaliException e) {
25419       {
25420         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25421       };
25422     } catch (...) {
25423       {
25424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25425       };
25426     }
25427   }
25428
25429   jresult = (unsigned long)result;
25430   return jresult;
25431 }
25432
25433
25434 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_New(void * jarg1) {
25435   void * jresult ;
25436   Dali::Property::Map *arg1 = 0 ;
25437   Dali::PropertyBuffer result;
25438
25439   arg1 = (Dali::Property::Map *)jarg1;
25440   if (!arg1) {
25441     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
25442     return 0;
25443   }
25444   {
25445     try {
25446       result = Dali::PropertyBuffer::New(*arg1);
25447     } catch (std::out_of_range& e) {
25448       {
25449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25450       };
25451     } catch (std::exception& e) {
25452       {
25453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25454       };
25455     } catch (Dali::DaliException e) {
25456       {
25457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25458       };
25459     } catch (...) {
25460       {
25461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25462       };
25463     }
25464   }
25465
25466   jresult = new Dali::PropertyBuffer((const Dali::PropertyBuffer &)result);
25467   return jresult;
25468 }
25469
25470
25471 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyBuffer__SWIG_0() {
25472   void * jresult ;
25473   Dali::PropertyBuffer *result = 0 ;
25474
25475   {
25476     try {
25477       result = (Dali::PropertyBuffer *)new Dali::PropertyBuffer();
25478     } catch (std::out_of_range& e) {
25479       {
25480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25481       };
25482     } catch (std::exception& e) {
25483       {
25484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25485       };
25486     } catch (Dali::DaliException e) {
25487       {
25488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25489       };
25490     } catch (...) {
25491       {
25492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25493       };
25494     }
25495   }
25496
25497   jresult = (void *)result;
25498   return jresult;
25499 }
25500
25501
25502 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyBuffer(void * jarg1) {
25503   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25504
25505   arg1 = (Dali::PropertyBuffer *)jarg1;
25506   {
25507     try {
25508       delete arg1;
25509     } catch (std::out_of_range& e) {
25510       {
25511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25512       };
25513     } catch (std::exception& e) {
25514       {
25515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25516       };
25517     } catch (Dali::DaliException e) {
25518       {
25519         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25520       };
25521     } catch (...) {
25522       {
25523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25524       };
25525     }
25526   }
25527
25528 }
25529
25530
25531 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyBuffer__SWIG_1(void * jarg1) {
25532   void * jresult ;
25533   Dali::PropertyBuffer *arg1 = 0 ;
25534   Dali::PropertyBuffer *result = 0 ;
25535
25536   arg1 = (Dali::PropertyBuffer *)jarg1;
25537   if (!arg1) {
25538     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer const & type is null", 0);
25539     return 0;
25540   }
25541   {
25542     try {
25543       result = (Dali::PropertyBuffer *)new Dali::PropertyBuffer((Dali::PropertyBuffer const &)*arg1);
25544     } catch (std::out_of_range& e) {
25545       {
25546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25547       };
25548     } catch (std::exception& e) {
25549       {
25550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25551       };
25552     } catch (Dali::DaliException e) {
25553       {
25554         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25555       };
25556     } catch (...) {
25557       {
25558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25559       };
25560     }
25561   }
25562
25563   jresult = (void *)result;
25564   return jresult;
25565 }
25566
25567
25568 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_DownCast(void * jarg1) {
25569   void * jresult ;
25570   Dali::BaseHandle arg1 ;
25571   Dali::BaseHandle *argp1 ;
25572   Dali::PropertyBuffer result;
25573
25574   argp1 = (Dali::BaseHandle *)jarg1;
25575   if (!argp1) {
25576     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
25577     return 0;
25578   }
25579   arg1 = *argp1;
25580   {
25581     try {
25582       result = Dali::PropertyBuffer::DownCast(arg1);
25583     } catch (std::out_of_range& e) {
25584       {
25585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25586       };
25587     } catch (std::exception& e) {
25588       {
25589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25590       };
25591     } catch (Dali::DaliException e) {
25592       {
25593         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25594       };
25595     } catch (...) {
25596       {
25597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25598       };
25599     }
25600   }
25601
25602   jresult = new Dali::PropertyBuffer((const Dali::PropertyBuffer &)result);
25603   return jresult;
25604 }
25605
25606
25607 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_Assign(void * jarg1, void * jarg2) {
25608   void * jresult ;
25609   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25610   Dali::PropertyBuffer *arg2 = 0 ;
25611   Dali::PropertyBuffer *result = 0 ;
25612
25613   arg1 = (Dali::PropertyBuffer *)jarg1;
25614   arg2 = (Dali::PropertyBuffer *)jarg2;
25615   if (!arg2) {
25616     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer const & type is null", 0);
25617     return 0;
25618   }
25619   {
25620     try {
25621       result = (Dali::PropertyBuffer *) &(arg1)->operator =((Dali::PropertyBuffer const &)*arg2);
25622     } catch (std::out_of_range& e) {
25623       {
25624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25625       };
25626     } catch (std::exception& e) {
25627       {
25628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25629       };
25630     } catch (Dali::DaliException e) {
25631       {
25632         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25633       };
25634     } catch (...) {
25635       {
25636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25637       };
25638     }
25639   }
25640
25641   jresult = (void *)result;
25642   return jresult;
25643 }
25644
25645
25646 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyBuffer_SetData(void * jarg1, void * jarg2, unsigned long jarg3) {
25647   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25648   void *arg2 = (void *) 0 ;
25649   std::size_t arg3 ;
25650
25651   arg1 = (Dali::PropertyBuffer *)jarg1;
25652   arg2 = jarg2;
25653   arg3 = (std::size_t)jarg3;
25654   {
25655     try {
25656       (arg1)->SetData((void const *)arg2,arg3);
25657     } catch (std::out_of_range& e) {
25658       {
25659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25660       };
25661     } catch (std::exception& e) {
25662       {
25663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25664       };
25665     } catch (Dali::DaliException e) {
25666       {
25667         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25668       };
25669     } catch (...) {
25670       {
25671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25672       };
25673     }
25674   }
25675
25676 }
25677
25678
25679 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyBuffer_GetSize(void * jarg1) {
25680   unsigned long jresult ;
25681   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25682   std::size_t result;
25683
25684   arg1 = (Dali::PropertyBuffer *)jarg1;
25685   {
25686     try {
25687       result = ((Dali::PropertyBuffer const *)arg1)->GetSize();
25688     } catch (std::out_of_range& e) {
25689       {
25690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25691       };
25692     } catch (std::exception& e) {
25693       {
25694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25695       };
25696     } catch (Dali::DaliException e) {
25697       {
25698         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25699       };
25700     } catch (...) {
25701       {
25702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25703       };
25704     }
25705   }
25706
25707   jresult = (unsigned long)result;
25708   return jresult;
25709 }
25710
25711
25712 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_New() {
25713   void * jresult ;
25714   Dali::Geometry result;
25715
25716   {
25717     try {
25718       result = Dali::Geometry::New();
25719     } catch (std::out_of_range& e) {
25720       {
25721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25722       };
25723     } catch (std::exception& e) {
25724       {
25725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25726       };
25727     } catch (Dali::DaliException e) {
25728       {
25729         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25730       };
25731     } catch (...) {
25732       {
25733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25734       };
25735     }
25736   }
25737
25738   jresult = new Dali::Geometry((const Dali::Geometry &)result);
25739   return jresult;
25740 }
25741
25742
25743 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_0() {
25744   void * jresult ;
25745   Dali::Geometry *result = 0 ;
25746
25747   {
25748     try {
25749       result = (Dali::Geometry *)new Dali::Geometry();
25750     } catch (std::out_of_range& e) {
25751       {
25752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25753       };
25754     } catch (std::exception& e) {
25755       {
25756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25757       };
25758     } catch (Dali::DaliException e) {
25759       {
25760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25761       };
25762     } catch (...) {
25763       {
25764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25765       };
25766     }
25767   }
25768
25769   jresult = (void *)result;
25770   return jresult;
25771 }
25772
25773
25774 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Geometry(void * jarg1) {
25775   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25776
25777   arg1 = (Dali::Geometry *)jarg1;
25778   {
25779     try {
25780       delete arg1;
25781     } catch (std::out_of_range& e) {
25782       {
25783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25784       };
25785     } catch (std::exception& e) {
25786       {
25787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25788       };
25789     } catch (Dali::DaliException e) {
25790       {
25791         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25792       };
25793     } catch (...) {
25794       {
25795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25796       };
25797     }
25798   }
25799
25800 }
25801
25802
25803 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_1(void * jarg1) {
25804   void * jresult ;
25805   Dali::Geometry *arg1 = 0 ;
25806   Dali::Geometry *result = 0 ;
25807
25808   arg1 = (Dali::Geometry *)jarg1;
25809   if (!arg1) {
25810     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
25811     return 0;
25812   }
25813   {
25814     try {
25815       result = (Dali::Geometry *)new Dali::Geometry((Dali::Geometry const &)*arg1);
25816     } catch (std::out_of_range& e) {
25817       {
25818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25819       };
25820     } catch (std::exception& e) {
25821       {
25822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25823       };
25824     } catch (Dali::DaliException e) {
25825       {
25826         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25827       };
25828     } catch (...) {
25829       {
25830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25831       };
25832     }
25833   }
25834
25835   jresult = (void *)result;
25836   return jresult;
25837 }
25838
25839
25840 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_DownCast(void * jarg1) {
25841   void * jresult ;
25842   Dali::BaseHandle arg1 ;
25843   Dali::BaseHandle *argp1 ;
25844   Dali::Geometry result;
25845
25846   argp1 = (Dali::BaseHandle *)jarg1;
25847   if (!argp1) {
25848     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
25849     return 0;
25850   }
25851   arg1 = *argp1;
25852   {
25853     try {
25854       result = Dali::Geometry::DownCast(arg1);
25855     } catch (std::out_of_range& e) {
25856       {
25857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25858       };
25859     } catch (std::exception& e) {
25860       {
25861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25862       };
25863     } catch (Dali::DaliException e) {
25864       {
25865         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25866       };
25867     } catch (...) {
25868       {
25869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25870       };
25871     }
25872   }
25873
25874   jresult = new Dali::Geometry((const Dali::Geometry &)result);
25875   return jresult;
25876 }
25877
25878
25879 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_Assign(void * jarg1, void * jarg2) {
25880   void * jresult ;
25881   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25882   Dali::Geometry *arg2 = 0 ;
25883   Dali::Geometry *result = 0 ;
25884
25885   arg1 = (Dali::Geometry *)jarg1;
25886   arg2 = (Dali::Geometry *)jarg2;
25887   if (!arg2) {
25888     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
25889     return 0;
25890   }
25891   {
25892     try {
25893       result = (Dali::Geometry *) &(arg1)->operator =((Dali::Geometry const &)*arg2);
25894     } catch (std::out_of_range& e) {
25895       {
25896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25897       };
25898     } catch (std::exception& e) {
25899       {
25900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25901       };
25902     } catch (Dali::DaliException e) {
25903       {
25904         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25905       };
25906     } catch (...) {
25907       {
25908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25909       };
25910     }
25911   }
25912
25913   jresult = (void *)result;
25914   return jresult;
25915 }
25916
25917
25918 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_AddVertexBuffer(void * jarg1, void * jarg2) {
25919   unsigned long jresult ;
25920   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25921   Dali::PropertyBuffer *arg2 = 0 ;
25922   std::size_t result;
25923
25924   arg1 = (Dali::Geometry *)jarg1;
25925   arg2 = (Dali::PropertyBuffer *)jarg2;
25926   if (!arg2) {
25927     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer & type is null", 0);
25928     return 0;
25929   }
25930   {
25931     try {
25932       result = (arg1)->AddVertexBuffer(*arg2);
25933     } catch (std::out_of_range& e) {
25934       {
25935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25936       };
25937     } catch (std::exception& e) {
25938       {
25939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25940       };
25941     } catch (Dali::DaliException e) {
25942       {
25943         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25944       };
25945     } catch (...) {
25946       {
25947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25948       };
25949     }
25950   }
25951
25952   jresult = (unsigned long)result;
25953   return jresult;
25954 }
25955
25956
25957 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_GetNumberOfVertexBuffers(void * jarg1) {
25958   unsigned long jresult ;
25959   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25960   std::size_t result;
25961
25962   arg1 = (Dali::Geometry *)jarg1;
25963   {
25964     try {
25965       result = ((Dali::Geometry const *)arg1)->GetNumberOfVertexBuffers();
25966     } catch (std::out_of_range& e) {
25967       {
25968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25969       };
25970     } catch (std::exception& e) {
25971       {
25972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25973       };
25974     } catch (Dali::DaliException e) {
25975       {
25976         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25977       };
25978     } catch (...) {
25979       {
25980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25981       };
25982     }
25983   }
25984
25985   jresult = (unsigned long)result;
25986   return jresult;
25987 }
25988
25989
25990 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_RemoveVertexBuffer(void * jarg1, unsigned long jarg2) {
25991   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25992   std::size_t arg2 ;
25993
25994   arg1 = (Dali::Geometry *)jarg1;
25995   arg2 = (std::size_t)jarg2;
25996   {
25997     try {
25998       (arg1)->RemoveVertexBuffer(arg2);
25999     } catch (std::out_of_range& e) {
26000       {
26001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26002       };
26003     } catch (std::exception& e) {
26004       {
26005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26006       };
26007     } catch (Dali::DaliException e) {
26008       {
26009         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26010       };
26011     } catch (...) {
26012       {
26013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26014       };
26015     }
26016   }
26017
26018 }
26019
26020
26021 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetIndexBuffer(void * jarg1, unsigned short* jarg2, unsigned long jarg3) {
26022   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
26023   unsigned short *arg2 = (unsigned short *) 0 ;
26024   size_t arg3 ;
26025
26026   arg1 = (Dali::Geometry *)jarg1;
26027   arg2 = jarg2;
26028   arg3 = (size_t)jarg3;
26029   {
26030     try {
26031       (arg1)->SetIndexBuffer((unsigned short const *)arg2,arg3);
26032     } catch (std::out_of_range& e) {
26033       {
26034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26035       };
26036     } catch (std::exception& e) {
26037       {
26038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26039       };
26040     } catch (Dali::DaliException e) {
26041       {
26042         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26043       };
26044     } catch (...) {
26045       {
26046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26047       };
26048     }
26049   }
26050
26051
26052
26053 }
26054
26055
26056 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetType(void * jarg1, int jarg2) {
26057   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
26058   Dali::Geometry::Type arg2 ;
26059
26060   arg1 = (Dali::Geometry *)jarg1;
26061   arg2 = (Dali::Geometry::Type)jarg2;
26062   {
26063     try {
26064       (arg1)->SetType(arg2);
26065     } catch (std::out_of_range& e) {
26066       {
26067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26068       };
26069     } catch (std::exception& e) {
26070       {
26071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26072       };
26073     } catch (Dali::DaliException e) {
26074       {
26075         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26076       };
26077     } catch (...) {
26078       {
26079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26080       };
26081     }
26082   }
26083
26084 }
26085
26086
26087 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Geometry_GetType(void * jarg1) {
26088   int jresult ;
26089   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
26090   Dali::Geometry::Type result;
26091
26092   arg1 = (Dali::Geometry *)jarg1;
26093   {
26094     try {
26095       result = (Dali::Geometry::Type)((Dali::Geometry const *)arg1)->GetType();
26096     } catch (std::out_of_range& e) {
26097       {
26098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26099       };
26100     } catch (std::exception& e) {
26101       {
26102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26103       };
26104     } catch (Dali::DaliException e) {
26105       {
26106         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26107       };
26108     } catch (...) {
26109       {
26110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26111       };
26112     }
26113   }
26114
26115   jresult = (int)result;
26116   return jresult;
26117 }
26118
26119
26120 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Hint() {
26121   void * jresult ;
26122   Dali::Shader::Hint *result = 0 ;
26123
26124   {
26125     try {
26126       result = (Dali::Shader::Hint *)new Dali::Shader::Hint();
26127     } catch (std::out_of_range& e) {
26128       {
26129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26130       };
26131     } catch (std::exception& e) {
26132       {
26133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26134       };
26135     } catch (Dali::DaliException e) {
26136       {
26137         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26138       };
26139     } catch (...) {
26140       {
26141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26142       };
26143     }
26144   }
26145
26146   jresult = (void *)result;
26147   return jresult;
26148 }
26149
26150
26151 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Hint(void * jarg1) {
26152   Dali::Shader::Hint *arg1 = (Dali::Shader::Hint *) 0 ;
26153
26154   arg1 = (Dali::Shader::Hint *)jarg1;
26155   {
26156     try {
26157       delete arg1;
26158     } catch (std::out_of_range& e) {
26159       {
26160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26161       };
26162     } catch (std::exception& e) {
26163       {
26164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26165       };
26166     } catch (Dali::DaliException e) {
26167       {
26168         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26169       };
26170     } catch (...) {
26171       {
26172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26173       };
26174     }
26175   }
26176
26177 }
26178
26179
26180 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Shader_Property_PROGRAM_get() {
26181   int jresult ;
26182   int result;
26183
26184   result = (int)Dali::Shader::Property::PROGRAM;
26185   jresult = (int)result;
26186   return jresult;
26187 }
26188
26189
26190 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Property() {
26191   void * jresult ;
26192   Dali::Shader::Property *result = 0 ;
26193
26194   {
26195     try {
26196       result = (Dali::Shader::Property *)new Dali::Shader::Property();
26197     } catch (std::out_of_range& e) {
26198       {
26199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26200       };
26201     } catch (std::exception& e) {
26202       {
26203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26204       };
26205     } catch (Dali::DaliException e) {
26206       {
26207         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26208       };
26209     } catch (...) {
26210       {
26211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26212       };
26213     }
26214   }
26215
26216   jresult = (void *)result;
26217   return jresult;
26218 }
26219
26220
26221 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Property(void * jarg1) {
26222   Dali::Shader::Property *arg1 = (Dali::Shader::Property *) 0 ;
26223
26224   arg1 = (Dali::Shader::Property *)jarg1;
26225   {
26226     try {
26227       delete arg1;
26228     } catch (std::out_of_range& e) {
26229       {
26230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26231       };
26232     } catch (std::exception& e) {
26233       {
26234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26235       };
26236     } catch (Dali::DaliException e) {
26237       {
26238         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26239       };
26240     } catch (...) {
26241       {
26242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26243       };
26244     }
26245   }
26246
26247 }
26248
26249
26250 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_0(char * jarg1, char * jarg2, int jarg3) {
26251   void * jresult ;
26252   std::string *arg1 = 0 ;
26253   std::string *arg2 = 0 ;
26254   Dali::Shader::Hint::Value arg3 ;
26255   Dali::Shader result;
26256
26257   if (!jarg1) {
26258     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26259     return 0;
26260   }
26261   std::string arg1_str(jarg1);
26262   arg1 = &arg1_str;
26263   if (!jarg2) {
26264     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26265     return 0;
26266   }
26267   std::string arg2_str(jarg2);
26268   arg2 = &arg2_str;
26269   arg3 = (Dali::Shader::Hint::Value)jarg3;
26270   {
26271     try {
26272       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2,arg3);
26273     } catch (std::out_of_range& e) {
26274       {
26275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26276       };
26277     } catch (std::exception& e) {
26278       {
26279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26280       };
26281     } catch (Dali::DaliException e) {
26282       {
26283         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26284       };
26285     } catch (...) {
26286       {
26287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26288       };
26289     }
26290   }
26291
26292   jresult = new Dali::Shader((const Dali::Shader &)result);
26293
26294   //argout typemap for const std::string&
26295
26296
26297   //argout typemap for const std::string&
26298
26299   return jresult;
26300 }
26301
26302
26303 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_1(char * jarg1, char * jarg2) {
26304   void * jresult ;
26305   std::string *arg1 = 0 ;
26306   std::string *arg2 = 0 ;
26307   Dali::Shader result;
26308
26309   if (!jarg1) {
26310     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26311     return 0;
26312   }
26313   std::string arg1_str(jarg1);
26314   arg1 = &arg1_str;
26315   if (!jarg2) {
26316     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26317     return 0;
26318   }
26319   std::string arg2_str(jarg2);
26320   arg2 = &arg2_str;
26321   {
26322     try {
26323       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2);
26324     } catch (std::out_of_range& e) {
26325       {
26326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26327       };
26328     } catch (std::exception& e) {
26329       {
26330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26331       };
26332     } catch (Dali::DaliException e) {
26333       {
26334         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26335       };
26336     } catch (...) {
26337       {
26338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26339       };
26340     }
26341   }
26342
26343   jresult = new Dali::Shader((const Dali::Shader &)result);
26344
26345   //argout typemap for const std::string&
26346
26347
26348   //argout typemap for const std::string&
26349
26350   return jresult;
26351 }
26352
26353
26354 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_0() {
26355   void * jresult ;
26356   Dali::Shader *result = 0 ;
26357
26358   {
26359     try {
26360       result = (Dali::Shader *)new Dali::Shader();
26361     } catch (std::out_of_range& e) {
26362       {
26363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26364       };
26365     } catch (std::exception& e) {
26366       {
26367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26368       };
26369     } catch (Dali::DaliException e) {
26370       {
26371         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26372       };
26373     } catch (...) {
26374       {
26375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26376       };
26377     }
26378   }
26379
26380   jresult = (void *)result;
26381   return jresult;
26382 }
26383
26384
26385 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader(void * jarg1) {
26386   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
26387
26388   arg1 = (Dali::Shader *)jarg1;
26389   {
26390     try {
26391       delete arg1;
26392     } catch (std::out_of_range& e) {
26393       {
26394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26395       };
26396     } catch (std::exception& e) {
26397       {
26398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26399       };
26400     } catch (Dali::DaliException e) {
26401       {
26402         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26403       };
26404     } catch (...) {
26405       {
26406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26407       };
26408     }
26409   }
26410
26411 }
26412
26413
26414 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_1(void * jarg1) {
26415   void * jresult ;
26416   Dali::Shader *arg1 = 0 ;
26417   Dali::Shader *result = 0 ;
26418
26419   arg1 = (Dali::Shader *)jarg1;
26420   if (!arg1) {
26421     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
26422     return 0;
26423   }
26424   {
26425     try {
26426       result = (Dali::Shader *)new Dali::Shader((Dali::Shader const &)*arg1);
26427     } catch (std::out_of_range& e) {
26428       {
26429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26430       };
26431     } catch (std::exception& e) {
26432       {
26433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26434       };
26435     } catch (Dali::DaliException e) {
26436       {
26437         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26438       };
26439     } catch (...) {
26440       {
26441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26442       };
26443     }
26444   }
26445
26446   jresult = (void *)result;
26447   return jresult;
26448 }
26449
26450
26451 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_DownCast(void * jarg1) {
26452   void * jresult ;
26453   Dali::BaseHandle arg1 ;
26454   Dali::BaseHandle *argp1 ;
26455   Dali::Shader result;
26456
26457   argp1 = (Dali::BaseHandle *)jarg1;
26458   if (!argp1) {
26459     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
26460     return 0;
26461   }
26462   arg1 = *argp1;
26463   {
26464     try {
26465       result = Dali::Shader::DownCast(arg1);
26466     } catch (std::out_of_range& e) {
26467       {
26468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26469       };
26470     } catch (std::exception& e) {
26471       {
26472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26473       };
26474     } catch (Dali::DaliException e) {
26475       {
26476         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26477       };
26478     } catch (...) {
26479       {
26480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26481       };
26482     }
26483   }
26484
26485   jresult = new Dali::Shader((const Dali::Shader &)result);
26486   return jresult;
26487 }
26488
26489
26490 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_Assign(void * jarg1, void * jarg2) {
26491   void * jresult ;
26492   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
26493   Dali::Shader *arg2 = 0 ;
26494   Dali::Shader *result = 0 ;
26495
26496   arg1 = (Dali::Shader *)jarg1;
26497   arg2 = (Dali::Shader *)jarg2;
26498   if (!arg2) {
26499     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
26500     return 0;
26501   }
26502   {
26503     try {
26504       result = (Dali::Shader *) &(arg1)->operator =((Dali::Shader const &)*arg2);
26505     } catch (std::out_of_range& e) {
26506       {
26507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26508       };
26509     } catch (std::exception& e) {
26510       {
26511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26512       };
26513     } catch (Dali::DaliException e) {
26514       {
26515         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26516       };
26517     } catch (...) {
26518       {
26519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26520       };
26521     }
26522   }
26523
26524   jresult = (void *)result;
26525   return jresult;
26526 }
26527
26528
26529 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_INDEX_get() {
26530   int jresult ;
26531   int result;
26532
26533   result = (int)Dali::Renderer::Property::DEPTH_INDEX;
26534   jresult = (int)result;
26535   return jresult;
26536 }
26537
26538
26539 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_FACE_CULLING_MODE_get() {
26540   int jresult ;
26541   int result;
26542
26543   result = (int)Dali::Renderer::Property::FACE_CULLING_MODE;
26544   jresult = (int)result;
26545   return jresult;
26546 }
26547
26548
26549 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_MODE_get() {
26550   int jresult ;
26551   int result;
26552
26553   result = (int)Dali::Renderer::Property::BLEND_MODE;
26554   jresult = (int)result;
26555   return jresult;
26556 }
26557
26558
26559 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_RGB_get() {
26560   int jresult ;
26561   int result;
26562
26563   result = (int)Dali::Renderer::Property::BLEND_EQUATION_RGB;
26564   jresult = (int)result;
26565   return jresult;
26566 }
26567
26568
26569 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_ALPHA_get() {
26570   int jresult ;
26571   int result;
26572
26573   result = (int)Dali::Renderer::Property::BLEND_EQUATION_ALPHA;
26574   jresult = (int)result;
26575   return jresult;
26576 }
26577
26578
26579 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_RGB_get() {
26580   int jresult ;
26581   int result;
26582
26583   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_RGB;
26584   jresult = (int)result;
26585   return jresult;
26586 }
26587
26588
26589 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_RGB_get() {
26590   int jresult ;
26591   int result;
26592
26593   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_RGB;
26594   jresult = (int)result;
26595   return jresult;
26596 }
26597
26598
26599 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_ALPHA_get() {
26600   int jresult ;
26601   int result;
26602
26603   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_ALPHA;
26604   jresult = (int)result;
26605   return jresult;
26606 }
26607
26608
26609 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_ALPHA_get() {
26610   int jresult ;
26611   int result;
26612
26613   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_ALPHA;
26614   jresult = (int)result;
26615   return jresult;
26616 }
26617
26618
26619 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_COLOR_get() {
26620   int jresult ;
26621   int result;
26622
26623   result = (int)Dali::Renderer::Property::BLEND_COLOR;
26624   jresult = (int)result;
26625   return jresult;
26626 }
26627
26628
26629 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_PRE_MULTIPLIED_ALPHA_get() {
26630   int jresult ;
26631   int result;
26632
26633   result = (int)Dali::Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA;
26634   jresult = (int)result;
26635   return jresult;
26636 }
26637
26638
26639 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_FIRST_get() {
26640   int jresult ;
26641   int result;
26642
26643   result = (int)Dali::Renderer::Property::INDEX_RANGE_FIRST;
26644   jresult = (int)result;
26645   return jresult;
26646 }
26647
26648
26649 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_COUNT_get() {
26650   int jresult ;
26651   int result;
26652
26653   result = (int)Dali::Renderer::Property::INDEX_RANGE_COUNT;
26654   jresult = (int)result;
26655   return jresult;
26656 }
26657
26658
26659 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_WRITE_MODE_get() {
26660   int jresult ;
26661   int result;
26662
26663   result = (int)Dali::Renderer::Property::DEPTH_WRITE_MODE;
26664   jresult = (int)result;
26665   return jresult;
26666 }
26667
26668
26669 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_FUNCTION_get() {
26670   int jresult ;
26671   int result;
26672
26673   result = (int)Dali::Renderer::Property::DEPTH_FUNCTION;
26674   jresult = (int)result;
26675   return jresult;
26676 }
26677
26678
26679 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_TEST_MODE_get() {
26680   int jresult ;
26681   int result;
26682
26683   result = (int)Dali::Renderer::Property::DEPTH_TEST_MODE;
26684   jresult = (int)result;
26685   return jresult;
26686 }
26687
26688
26689 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_RENDER_MODE_get() {
26690   int jresult ;
26691   int result;
26692
26693   result = (int)Dali::Renderer::Property::RENDER_MODE;
26694   jresult = (int)result;
26695   return jresult;
26696 }
26697
26698
26699 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_get() {
26700   int jresult ;
26701   int result;
26702
26703   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION;
26704   jresult = (int)result;
26705   return jresult;
26706 }
26707
26708
26709 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_MASK_get() {
26710   int jresult ;
26711   int result;
26712
26713   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_MASK;
26714   jresult = (int)result;
26715   return jresult;
26716 }
26717
26718
26719 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_REFERENCE_get() {
26720   int jresult ;
26721   int result;
26722
26723   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_REFERENCE;
26724   jresult = (int)result;
26725   return jresult;
26726 }
26727
26728
26729 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_MASK_get() {
26730   int jresult ;
26731   int result;
26732
26733   result = (int)Dali::Renderer::Property::STENCIL_MASK;
26734   jresult = (int)result;
26735   return jresult;
26736 }
26737
26738
26739 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_FAIL_get() {
26740   int jresult ;
26741   int result;
26742
26743   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_FAIL;
26744   jresult = (int)result;
26745   return jresult;
26746 }
26747
26748
26749 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_FAIL_get() {
26750   int jresult ;
26751   int result;
26752
26753   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_FAIL;
26754   jresult = (int)result;
26755   return jresult;
26756 }
26757
26758
26759 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_PASS_get() {
26760   int jresult ;
26761   int result;
26762
26763   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_PASS;
26764   jresult = (int)result;
26765   return jresult;
26766 }
26767
26768
26769 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer_Property() {
26770   void * jresult ;
26771   Dali::Renderer::Property *result = 0 ;
26772
26773   {
26774     try {
26775       result = (Dali::Renderer::Property *)new Dali::Renderer::Property();
26776     } catch (std::out_of_range& e) {
26777       {
26778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26779       };
26780     } catch (std::exception& e) {
26781       {
26782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26783       };
26784     } catch (Dali::DaliException e) {
26785       {
26786         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26787       };
26788     } catch (...) {
26789       {
26790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26791       };
26792     }
26793   }
26794
26795   jresult = (void *)result;
26796   return jresult;
26797 }
26798
26799
26800 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer_Property(void * jarg1) {
26801   Dali::Renderer::Property *arg1 = (Dali::Renderer::Property *) 0 ;
26802
26803   arg1 = (Dali::Renderer::Property *)jarg1;
26804   {
26805     try {
26806       delete arg1;
26807     } catch (std::out_of_range& e) {
26808       {
26809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26810       };
26811     } catch (std::exception& e) {
26812       {
26813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26814       };
26815     } catch (Dali::DaliException e) {
26816       {
26817         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26818       };
26819     } catch (...) {
26820       {
26821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26822       };
26823     }
26824   }
26825
26826 }
26827
26828
26829 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_New(void * jarg1, void * jarg2) {
26830   void * jresult ;
26831   Dali::Geometry *arg1 = 0 ;
26832   Dali::Shader *arg2 = 0 ;
26833   Dali::Renderer result;
26834
26835   arg1 = (Dali::Geometry *)jarg1;
26836   if (!arg1) {
26837     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
26838     return 0;
26839   }
26840   arg2 = (Dali::Shader *)jarg2;
26841   if (!arg2) {
26842     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
26843     return 0;
26844   }
26845   {
26846     try {
26847       result = Dali::Renderer::New(*arg1,*arg2);
26848     } catch (std::out_of_range& e) {
26849       {
26850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26851       };
26852     } catch (std::exception& e) {
26853       {
26854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26855       };
26856     } catch (Dali::DaliException e) {
26857       {
26858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26859       };
26860     } catch (...) {
26861       {
26862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26863       };
26864     }
26865   }
26866
26867   jresult = new Dali::Renderer((const Dali::Renderer &)result);
26868   return jresult;
26869 }
26870
26871
26872 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_0() {
26873   void * jresult ;
26874   Dali::Renderer *result = 0 ;
26875
26876   {
26877     try {
26878       result = (Dali::Renderer *)new Dali::Renderer();
26879     } catch (std::out_of_range& e) {
26880       {
26881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26882       };
26883     } catch (std::exception& e) {
26884       {
26885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26886       };
26887     } catch (Dali::DaliException e) {
26888       {
26889         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26890       };
26891     } catch (...) {
26892       {
26893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26894       };
26895     }
26896   }
26897
26898   jresult = (void *)result;
26899   return jresult;
26900 }
26901
26902
26903 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer(void * jarg1) {
26904   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
26905
26906   arg1 = (Dali::Renderer *)jarg1;
26907   {
26908     try {
26909       delete arg1;
26910     } catch (std::out_of_range& e) {
26911       {
26912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26913       };
26914     } catch (std::exception& e) {
26915       {
26916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26917       };
26918     } catch (Dali::DaliException e) {
26919       {
26920         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26921       };
26922     } catch (...) {
26923       {
26924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26925       };
26926     }
26927   }
26928
26929 }
26930
26931
26932 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_1(void * jarg1) {
26933   void * jresult ;
26934   Dali::Renderer *arg1 = 0 ;
26935   Dali::Renderer *result = 0 ;
26936
26937   arg1 = (Dali::Renderer *)jarg1;
26938   if (!arg1) {
26939     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
26940     return 0;
26941   }
26942   {
26943     try {
26944       result = (Dali::Renderer *)new Dali::Renderer((Dali::Renderer const &)*arg1);
26945     } catch (std::out_of_range& e) {
26946       {
26947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26948       };
26949     } catch (std::exception& e) {
26950       {
26951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26952       };
26953     } catch (Dali::DaliException e) {
26954       {
26955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26956       };
26957     } catch (...) {
26958       {
26959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26960       };
26961     }
26962   }
26963
26964   jresult = (void *)result;
26965   return jresult;
26966 }
26967
26968
26969 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_DownCast(void * jarg1) {
26970   void * jresult ;
26971   Dali::BaseHandle arg1 ;
26972   Dali::BaseHandle *argp1 ;
26973   Dali::Renderer result;
26974
26975   argp1 = (Dali::BaseHandle *)jarg1;
26976   if (!argp1) {
26977     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
26978     return 0;
26979   }
26980   arg1 = *argp1;
26981   {
26982     try {
26983       result = Dali::Renderer::DownCast(arg1);
26984     } catch (std::out_of_range& e) {
26985       {
26986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26987       };
26988     } catch (std::exception& e) {
26989       {
26990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26991       };
26992     } catch (Dali::DaliException e) {
26993       {
26994         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26995       };
26996     } catch (...) {
26997       {
26998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26999       };
27000     }
27001   }
27002
27003   jresult = new Dali::Renderer((const Dali::Renderer &)result);
27004   return jresult;
27005 }
27006
27007
27008 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_Assign(void * jarg1, void * jarg2) {
27009   void * jresult ;
27010   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27011   Dali::Renderer *arg2 = 0 ;
27012   Dali::Renderer *result = 0 ;
27013
27014   arg1 = (Dali::Renderer *)jarg1;
27015   arg2 = (Dali::Renderer *)jarg2;
27016   if (!arg2) {
27017     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
27018     return 0;
27019   }
27020   {
27021     try {
27022       result = (Dali::Renderer *) &(arg1)->operator =((Dali::Renderer const &)*arg2);
27023     } catch (std::out_of_range& e) {
27024       {
27025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27026       };
27027     } catch (std::exception& e) {
27028       {
27029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27030       };
27031     } catch (Dali::DaliException e) {
27032       {
27033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27034       };
27035     } catch (...) {
27036       {
27037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27038       };
27039     }
27040   }
27041
27042   jresult = (void *)result;
27043   return jresult;
27044 }
27045
27046
27047 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetGeometry(void * jarg1, void * jarg2) {
27048   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27049   Dali::Geometry *arg2 = 0 ;
27050
27051   arg1 = (Dali::Renderer *)jarg1;
27052   arg2 = (Dali::Geometry *)jarg2;
27053   if (!arg2) {
27054     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
27055     return ;
27056   }
27057   {
27058     try {
27059       (arg1)->SetGeometry(*arg2);
27060     } catch (std::out_of_range& e) {
27061       {
27062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27063       };
27064     } catch (std::exception& e) {
27065       {
27066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27067       };
27068     } catch (Dali::DaliException e) {
27069       {
27070         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27071       };
27072     } catch (...) {
27073       {
27074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27075       };
27076     }
27077   }
27078
27079 }
27080
27081
27082 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetGeometry(void * jarg1) {
27083   void * jresult ;
27084   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27085   Dali::Geometry result;
27086
27087   arg1 = (Dali::Renderer *)jarg1;
27088   {
27089     try {
27090       result = ((Dali::Renderer const *)arg1)->GetGeometry();
27091     } catch (std::out_of_range& e) {
27092       {
27093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27094       };
27095     } catch (std::exception& e) {
27096       {
27097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27098       };
27099     } catch (Dali::DaliException e) {
27100       {
27101         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27102       };
27103     } catch (...) {
27104       {
27105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27106       };
27107     }
27108   }
27109
27110   jresult = new Dali::Geometry((const Dali::Geometry &)result);
27111   return jresult;
27112 }
27113
27114
27115 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetIndexRange(void * jarg1, int jarg2, int jarg3) {
27116   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27117   int arg2 ;
27118   int arg3 ;
27119
27120   arg1 = (Dali::Renderer *)jarg1;
27121   arg2 = (int)jarg2;
27122   arg3 = (int)jarg3;
27123   {
27124     try {
27125       (arg1)->SetIndexRange(arg2,arg3);
27126     } catch (std::out_of_range& e) {
27127       {
27128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27129       };
27130     } catch (std::exception& e) {
27131       {
27132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27133       };
27134     } catch (Dali::DaliException e) {
27135       {
27136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27137       };
27138     } catch (...) {
27139       {
27140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27141       };
27142     }
27143   }
27144
27145 }
27146
27147
27148 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetTextures(void * jarg1, void * jarg2) {
27149   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27150   Dali::TextureSet *arg2 = 0 ;
27151
27152   arg1 = (Dali::Renderer *)jarg1;
27153   arg2 = (Dali::TextureSet *)jarg2;
27154   if (!arg2) {
27155     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet & type is null", 0);
27156     return ;
27157   }
27158   {
27159     try {
27160       (arg1)->SetTextures(*arg2);
27161     } catch (std::out_of_range& e) {
27162       {
27163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27164       };
27165     } catch (std::exception& e) {
27166       {
27167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27168       };
27169     } catch (Dali::DaliException e) {
27170       {
27171         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27172       };
27173     } catch (...) {
27174       {
27175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27176       };
27177     }
27178   }
27179
27180 }
27181
27182
27183 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetTextures(void * jarg1) {
27184   void * jresult ;
27185   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27186   Dali::TextureSet result;
27187
27188   arg1 = (Dali::Renderer *)jarg1;
27189   {
27190     try {
27191       result = ((Dali::Renderer const *)arg1)->GetTextures();
27192     } catch (std::out_of_range& e) {
27193       {
27194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27195       };
27196     } catch (std::exception& e) {
27197       {
27198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27199       };
27200     } catch (Dali::DaliException e) {
27201       {
27202         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27203       };
27204     } catch (...) {
27205       {
27206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27207       };
27208     }
27209   }
27210
27211   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
27212   return jresult;
27213 }
27214
27215
27216 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetShader(void * jarg1, void * jarg2) {
27217   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27218   Dali::Shader *arg2 = 0 ;
27219
27220   arg1 = (Dali::Renderer *)jarg1;
27221   arg2 = (Dali::Shader *)jarg2;
27222   if (!arg2) {
27223     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
27224     return ;
27225   }
27226   {
27227     try {
27228       (arg1)->SetShader(*arg2);
27229     } catch (std::out_of_range& e) {
27230       {
27231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27232       };
27233     } catch (std::exception& e) {
27234       {
27235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27236       };
27237     } catch (Dali::DaliException e) {
27238       {
27239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27240       };
27241     } catch (...) {
27242       {
27243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27244       };
27245     }
27246   }
27247
27248 }
27249
27250
27251 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetShader(void * jarg1) {
27252   void * jresult ;
27253   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27254   Dali::Shader result;
27255
27256   arg1 = (Dali::Renderer *)jarg1;
27257   {
27258     try {
27259       result = ((Dali::Renderer const *)arg1)->GetShader();
27260     } catch (std::out_of_range& e) {
27261       {
27262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27263       };
27264     } catch (std::exception& e) {
27265       {
27266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27267       };
27268     } catch (Dali::DaliException e) {
27269       {
27270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27271       };
27272     } catch (...) {
27273       {
27274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27275       };
27276     }
27277   }
27278
27279   jresult = new Dali::Shader((const Dali::Shader &)result);
27280   return jresult;
27281 }
27282
27283
27284 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer_Attachment() {
27285   void * jresult ;
27286   Dali::FrameBuffer::Attachment *result = 0 ;
27287
27288   {
27289     try {
27290       result = (Dali::FrameBuffer::Attachment *)new Dali::FrameBuffer::Attachment();
27291     } catch (std::out_of_range& e) {
27292       {
27293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27294       };
27295     } catch (std::exception& e) {
27296       {
27297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27298       };
27299     } catch (Dali::DaliException e) {
27300       {
27301         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27302       };
27303     } catch (...) {
27304       {
27305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27306       };
27307     }
27308   }
27309
27310   jresult = (void *)result;
27311   return jresult;
27312 }
27313
27314
27315 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer_Attachment(void * jarg1) {
27316   Dali::FrameBuffer::Attachment *arg1 = (Dali::FrameBuffer::Attachment *) 0 ;
27317
27318   arg1 = (Dali::FrameBuffer::Attachment *)jarg1;
27319   {
27320     try {
27321       delete arg1;
27322     } catch (std::out_of_range& e) {
27323       {
27324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27325       };
27326     } catch (std::exception& e) {
27327       {
27328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27329       };
27330     } catch (Dali::DaliException e) {
27331       {
27332         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27333       };
27334     } catch (...) {
27335       {
27336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27337       };
27338     }
27339   }
27340
27341 }
27342
27343
27344 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_New(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
27345   void * jresult ;
27346   unsigned int arg1 ;
27347   unsigned int arg2 ;
27348   unsigned int arg3 ;
27349   Dali::FrameBuffer result;
27350
27351   arg1 = (unsigned int)jarg1;
27352   arg2 = (unsigned int)jarg2;
27353   arg3 = (unsigned int)jarg3;
27354   {
27355     try {
27356       result = Dali::FrameBuffer::New(arg1,arg2,arg3);
27357     } catch (std::out_of_range& e) {
27358       {
27359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27360       };
27361     } catch (std::exception& e) {
27362       {
27363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27364       };
27365     } catch (Dali::DaliException e) {
27366       {
27367         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27368       };
27369     } catch (...) {
27370       {
27371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27372       };
27373     }
27374   }
27375
27376   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
27377   return jresult;
27378 }
27379
27380
27381 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_0() {
27382   void * jresult ;
27383   Dali::FrameBuffer *result = 0 ;
27384
27385   {
27386     try {
27387       result = (Dali::FrameBuffer *)new Dali::FrameBuffer();
27388     } catch (std::out_of_range& e) {
27389       {
27390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27391       };
27392     } catch (std::exception& e) {
27393       {
27394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27395       };
27396     } catch (Dali::DaliException e) {
27397       {
27398         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27399       };
27400     } catch (...) {
27401       {
27402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27403       };
27404     }
27405   }
27406
27407   jresult = (void *)result;
27408   return jresult;
27409 }
27410
27411
27412 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer(void * jarg1) {
27413   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27414
27415   arg1 = (Dali::FrameBuffer *)jarg1;
27416   {
27417     try {
27418       delete arg1;
27419     } catch (std::out_of_range& e) {
27420       {
27421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27422       };
27423     } catch (std::exception& e) {
27424       {
27425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27426       };
27427     } catch (Dali::DaliException e) {
27428       {
27429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27430       };
27431     } catch (...) {
27432       {
27433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27434       };
27435     }
27436   }
27437
27438 }
27439
27440
27441 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_1(void * jarg1) {
27442   void * jresult ;
27443   Dali::FrameBuffer *arg1 = 0 ;
27444   Dali::FrameBuffer *result = 0 ;
27445
27446   arg1 = (Dali::FrameBuffer *)jarg1;
27447   if (!arg1) {
27448     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
27449     return 0;
27450   }
27451   {
27452     try {
27453       result = (Dali::FrameBuffer *)new Dali::FrameBuffer((Dali::FrameBuffer const &)*arg1);
27454     } catch (std::out_of_range& e) {
27455       {
27456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27457       };
27458     } catch (std::exception& e) {
27459       {
27460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27461       };
27462     } catch (Dali::DaliException e) {
27463       {
27464         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27465       };
27466     } catch (...) {
27467       {
27468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27469       };
27470     }
27471   }
27472
27473   jresult = (void *)result;
27474   return jresult;
27475 }
27476
27477
27478 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_DownCast(void * jarg1) {
27479   void * jresult ;
27480   Dali::BaseHandle arg1 ;
27481   Dali::BaseHandle *argp1 ;
27482   Dali::FrameBuffer result;
27483
27484   argp1 = (Dali::BaseHandle *)jarg1;
27485   if (!argp1) {
27486     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27487     return 0;
27488   }
27489   arg1 = *argp1;
27490   {
27491     try {
27492       result = Dali::FrameBuffer::DownCast(arg1);
27493     } catch (std::out_of_range& e) {
27494       {
27495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27496       };
27497     } catch (std::exception& e) {
27498       {
27499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27500       };
27501     } catch (Dali::DaliException e) {
27502       {
27503         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27504       };
27505     } catch (...) {
27506       {
27507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27508       };
27509     }
27510   }
27511
27512   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
27513   return jresult;
27514 }
27515
27516
27517 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_Assign(void * jarg1, void * jarg2) {
27518   void * jresult ;
27519   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27520   Dali::FrameBuffer *arg2 = 0 ;
27521   Dali::FrameBuffer *result = 0 ;
27522
27523   arg1 = (Dali::FrameBuffer *)jarg1;
27524   arg2 = (Dali::FrameBuffer *)jarg2;
27525   if (!arg2) {
27526     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
27527     return 0;
27528   }
27529   {
27530     try {
27531       result = (Dali::FrameBuffer *) &(arg1)->operator =((Dali::FrameBuffer const &)*arg2);
27532     } catch (std::out_of_range& e) {
27533       {
27534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27535       };
27536     } catch (std::exception& e) {
27537       {
27538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27539       };
27540     } catch (Dali::DaliException e) {
27541       {
27542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27543       };
27544     } catch (...) {
27545       {
27546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27547       };
27548     }
27549   }
27550
27551   jresult = (void *)result;
27552   return jresult;
27553 }
27554
27555
27556 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_0(void * jarg1, void * jarg2) {
27557   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27558   Dali::Texture *arg2 = 0 ;
27559
27560   arg1 = (Dali::FrameBuffer *)jarg1;
27561   arg2 = (Dali::Texture *)jarg2;
27562   if (!arg2) {
27563     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
27564     return ;
27565   }
27566   {
27567     try {
27568       (arg1)->AttachColorTexture(*arg2);
27569     } catch (std::out_of_range& e) {
27570       {
27571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27572       };
27573     } catch (std::exception& e) {
27574       {
27575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27576       };
27577     } catch (Dali::DaliException e) {
27578       {
27579         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27580       };
27581     } catch (...) {
27582       {
27583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27584       };
27585     }
27586   }
27587
27588 }
27589
27590
27591 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_1(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
27592   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27593   Dali::Texture *arg2 = 0 ;
27594   unsigned int arg3 ;
27595   unsigned int arg4 ;
27596
27597   arg1 = (Dali::FrameBuffer *)jarg1;
27598   arg2 = (Dali::Texture *)jarg2;
27599   if (!arg2) {
27600     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
27601     return ;
27602   }
27603   arg3 = (unsigned int)jarg3;
27604   arg4 = (unsigned int)jarg4;
27605   {
27606     try {
27607       (arg1)->AttachColorTexture(*arg2,arg3,arg4);
27608     } catch (std::out_of_range& e) {
27609       {
27610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27611       };
27612     } catch (std::exception& e) {
27613       {
27614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27615       };
27616     } catch (Dali::DaliException e) {
27617       {
27618         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27619       };
27620     } catch (...) {
27621       {
27622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27623       };
27624     }
27625   }
27626
27627 }
27628
27629
27630 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_GetColorTexture(void * jarg1) {
27631   void * jresult ;
27632   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27633   Dali::Texture result;
27634
27635   arg1 = (Dali::FrameBuffer *)jarg1;
27636   {
27637     try {
27638       result = (arg1)->GetColorTexture();
27639     } catch (std::out_of_range& e) {
27640       {
27641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27642       };
27643     } catch (std::exception& e) {
27644       {
27645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27646       };
27647     } catch (Dali::DaliException e) {
27648       {
27649         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27650       };
27651     } catch (...) {
27652       {
27653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27654       };
27655     }
27656   }
27657
27658   jresult = new Dali::Texture((const Dali::Texture &)result);
27659   return jresult;
27660 }
27661
27662
27663 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_0() {
27664   void * jresult ;
27665   Dali::RenderTaskList *result = 0 ;
27666
27667   {
27668     try {
27669       result = (Dali::RenderTaskList *)new Dali::RenderTaskList();
27670     } catch (std::out_of_range& e) {
27671       {
27672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27673       };
27674     } catch (std::exception& e) {
27675       {
27676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27677       };
27678     } catch (Dali::DaliException e) {
27679       {
27680         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27681       };
27682     } catch (...) {
27683       {
27684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27685       };
27686     }
27687   }
27688
27689   jresult = (void *)result;
27690   return jresult;
27691 }
27692
27693
27694 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_DownCast(void * jarg1) {
27695   void * jresult ;
27696   Dali::BaseHandle arg1 ;
27697   Dali::BaseHandle *argp1 ;
27698   Dali::RenderTaskList result;
27699
27700   argp1 = (Dali::BaseHandle *)jarg1;
27701   if (!argp1) {
27702     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27703     return 0;
27704   }
27705   arg1 = *argp1;
27706   {
27707     try {
27708       result = Dali::RenderTaskList::DownCast(arg1);
27709     } catch (std::out_of_range& e) {
27710       {
27711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27712       };
27713     } catch (std::exception& e) {
27714       {
27715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27716       };
27717     } catch (Dali::DaliException e) {
27718       {
27719         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27720       };
27721     } catch (...) {
27722       {
27723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27724       };
27725     }
27726   }
27727
27728   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
27729   return jresult;
27730 }
27731
27732
27733 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskList(void * jarg1) {
27734   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27735
27736   arg1 = (Dali::RenderTaskList *)jarg1;
27737   {
27738     try {
27739       delete arg1;
27740     } catch (std::out_of_range& e) {
27741       {
27742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27743       };
27744     } catch (std::exception& e) {
27745       {
27746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27747       };
27748     } catch (Dali::DaliException e) {
27749       {
27750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27751       };
27752     } catch (...) {
27753       {
27754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27755       };
27756     }
27757   }
27758
27759 }
27760
27761
27762 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_1(void * jarg1) {
27763   void * jresult ;
27764   Dali::RenderTaskList *arg1 = 0 ;
27765   Dali::RenderTaskList *result = 0 ;
27766
27767   arg1 = (Dali::RenderTaskList *)jarg1;
27768   if (!arg1) {
27769     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
27770     return 0;
27771   }
27772   {
27773     try {
27774       result = (Dali::RenderTaskList *)new Dali::RenderTaskList((Dali::RenderTaskList const &)*arg1);
27775     } catch (std::out_of_range& e) {
27776       {
27777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27778       };
27779     } catch (std::exception& e) {
27780       {
27781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27782       };
27783     } catch (Dali::DaliException e) {
27784       {
27785         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27786       };
27787     } catch (...) {
27788       {
27789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27790       };
27791     }
27792   }
27793
27794   jresult = (void *)result;
27795   return jresult;
27796 }
27797
27798
27799 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_Assign(void * jarg1, void * jarg2) {
27800   void * jresult ;
27801   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27802   Dali::RenderTaskList *arg2 = 0 ;
27803   Dali::RenderTaskList *result = 0 ;
27804
27805   arg1 = (Dali::RenderTaskList *)jarg1;
27806   arg2 = (Dali::RenderTaskList *)jarg2;
27807   if (!arg2) {
27808     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
27809     return 0;
27810   }
27811   {
27812     try {
27813       result = (Dali::RenderTaskList *) &(arg1)->operator =((Dali::RenderTaskList const &)*arg2);
27814     } catch (std::out_of_range& e) {
27815       {
27816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27817       };
27818     } catch (std::exception& e) {
27819       {
27820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27821       };
27822     } catch (Dali::DaliException e) {
27823       {
27824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27825       };
27826     } catch (...) {
27827       {
27828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27829       };
27830     }
27831   }
27832
27833   jresult = (void *)result;
27834   return jresult;
27835 }
27836
27837
27838 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_CreateTask(void * jarg1) {
27839   void * jresult ;
27840   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27841   Dali::RenderTask result;
27842
27843   arg1 = (Dali::RenderTaskList *)jarg1;
27844   {
27845     try {
27846       result = (arg1)->CreateTask();
27847     } catch (std::out_of_range& e) {
27848       {
27849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27850       };
27851     } catch (std::exception& e) {
27852       {
27853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27854       };
27855     } catch (Dali::DaliException e) {
27856       {
27857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27858       };
27859     } catch (...) {
27860       {
27861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27862       };
27863     }
27864   }
27865
27866   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
27867   return jresult;
27868 }
27869
27870
27871 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTaskList_RemoveTask(void * jarg1, void * jarg2) {
27872   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27873   Dali::RenderTask arg2 ;
27874   Dali::RenderTask *argp2 ;
27875
27876   arg1 = (Dali::RenderTaskList *)jarg1;
27877   argp2 = (Dali::RenderTask *)jarg2;
27878   if (!argp2) {
27879     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RenderTask", 0);
27880     return ;
27881   }
27882   arg2 = *argp2;
27883   {
27884     try {
27885       (arg1)->RemoveTask(arg2);
27886     } catch (std::out_of_range& e) {
27887       {
27888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27889       };
27890     } catch (std::exception& e) {
27891       {
27892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27893       };
27894     } catch (Dali::DaliException e) {
27895       {
27896         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27897       };
27898     } catch (...) {
27899       {
27900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27901       };
27902     }
27903   }
27904
27905 }
27906
27907
27908 //// ===============================================end part 1 =================
27909
27910 //// ========================= part 2 ===============================
27911
27912 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTaskCount(void * jarg1) {
27913   unsigned int jresult ;
27914   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27915   unsigned int result;
27916
27917   arg1 = (Dali::RenderTaskList *)jarg1;
27918   {
27919     try {
27920       result = (unsigned int)((Dali::RenderTaskList const *)arg1)->GetTaskCount();
27921     } catch (std::out_of_range& e) {
27922       {
27923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27924       };
27925     } catch (std::exception& e) {
27926       {
27927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27928       };
27929     } catch (Dali::DaliException e) {
27930       {
27931         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27932       };
27933     } catch (...) {
27934       {
27935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27936       };
27937     }
27938   }
27939
27940   jresult = result;
27941   return jresult;
27942 }
27943
27944
27945 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTask(void * jarg1, unsigned int jarg2) {
27946   void * jresult ;
27947   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27948   unsigned int arg2 ;
27949   Dali::RenderTask result;
27950
27951   arg1 = (Dali::RenderTaskList *)jarg1;
27952   arg2 = (unsigned int)jarg2;
27953   {
27954     try {
27955       result = ((Dali::RenderTaskList const *)arg1)->GetTask(arg2);
27956     } catch (std::out_of_range& e) {
27957       {
27958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27959       };
27960     } catch (std::exception& e) {
27961       {
27962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27963       };
27964     } catch (Dali::DaliException e) {
27965       {
27966         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27967       };
27968     } catch (...) {
27969       {
27970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27971       };
27972     }
27973   }
27974
27975   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
27976   return jresult;
27977 }
27978
27979
27980 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_POSITION_get() {
27981   int jresult ;
27982   int result;
27983
27984   result = (int)Dali::RenderTask::Property::VIEWPORT_POSITION;
27985   jresult = (int)result;
27986   return jresult;
27987 }
27988
27989
27990 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_SIZE_get() {
27991   int jresult ;
27992   int result;
27993
27994   result = (int)Dali::RenderTask::Property::VIEWPORT_SIZE;
27995   jresult = (int)result;
27996   return jresult;
27997 }
27998
27999
28000 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_CLEAR_COLOR_get() {
28001   int jresult ;
28002   int result;
28003
28004   result = (int)Dali::RenderTask::Property::CLEAR_COLOR;
28005   jresult = (int)result;
28006   return jresult;
28007 }
28008
28009
28010 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_REQUIRES_SYNC_get() {
28011   int jresult ;
28012   int result;
28013
28014   result = (int)Dali::RenderTask::Property::REQUIRES_SYNC;
28015   jresult = (int)result;
28016   return jresult;
28017 }
28018
28019
28020 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask_Property() {
28021   void * jresult ;
28022   Dali::RenderTask::Property *result = 0 ;
28023
28024   {
28025     try {
28026       result = (Dali::RenderTask::Property *)new Dali::RenderTask::Property();
28027     } catch (std::out_of_range& e) {
28028       {
28029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28030       };
28031     } catch (std::exception& e) {
28032       {
28033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28034       };
28035     } catch (Dali::DaliException e) {
28036       {
28037         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28038       };
28039     } catch (...) {
28040       {
28041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28042       };
28043     }
28044   }
28045
28046   jresult = (void *)result;
28047   return jresult;
28048 }
28049
28050
28051 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask_Property(void * jarg1) {
28052   Dali::RenderTask::Property *arg1 = (Dali::RenderTask::Property *) 0 ;
28053
28054   arg1 = (Dali::RenderTask::Property *)jarg1;
28055   {
28056     try {
28057       delete arg1;
28058     } catch (std::out_of_range& e) {
28059       {
28060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28061       };
28062     } catch (std::exception& e) {
28063       {
28064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28065       };
28066     } catch (Dali::DaliException e) {
28067       {
28068         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28069       };
28070     } catch (...) {
28071       {
28072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28073       };
28074     }
28075   }
28076
28077 }
28078
28079
28080 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION_get() {
28081   void * jresult ;
28082   bool (*result)(Dali::Vector2 &) = 0 ;
28083
28084   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION;
28085   jresult = (void *)result;
28086   return jresult;
28087 }
28088
28089
28090 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FULLSCREEN_FRAMEBUFFER_FUNCTION_get() {
28091   void * jresult ;
28092   bool (*result)(Dali::Vector2 &) = 0 ;
28093
28094   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::FULLSCREEN_FRAMEBUFFER_FUNCTION;
28095   jresult = (void *)result;
28096   return jresult;
28097 }
28098
28099
28100 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_EXCLUSIVE_get() {
28101   unsigned int jresult ;
28102   bool result;
28103
28104   result = (bool)(bool)Dali::RenderTask::DEFAULT_EXCLUSIVE;
28105   jresult = result;
28106   return jresult;
28107 }
28108
28109
28110 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_INPUT_ENABLED_get() {
28111   unsigned int jresult ;
28112   bool result;
28113
28114   result = (bool)(bool)Dali::RenderTask::DEFAULT_INPUT_ENABLED;
28115   jresult = result;
28116   return jresult;
28117 }
28118
28119
28120 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_COLOR_get() {
28121   void * jresult ;
28122   Dali::Vector4 *result = 0 ;
28123
28124   result = (Dali::Vector4 *)&Dali::RenderTask::DEFAULT_CLEAR_COLOR;
28125   jresult = (void *)result;
28126   return jresult;
28127 }
28128
28129
28130 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_ENABLED_get() {
28131   unsigned int jresult ;
28132   bool result;
28133
28134   result = (bool)(bool)Dali::RenderTask::DEFAULT_CLEAR_ENABLED;
28135   jresult = result;
28136   return jresult;
28137 }
28138
28139
28140 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CULL_MODE_get() {
28141   unsigned int jresult ;
28142   bool result;
28143
28144   result = (bool)(bool)Dali::RenderTask::DEFAULT_CULL_MODE;
28145   jresult = result;
28146   return jresult;
28147 }
28148
28149
28150 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_REFRESH_RATE_get() {
28151   unsigned int jresult ;
28152   unsigned int result;
28153
28154   result = (unsigned int)(unsigned int)Dali::RenderTask::DEFAULT_REFRESH_RATE;
28155   jresult = result;
28156   return jresult;
28157 }
28158
28159
28160 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_0() {
28161   void * jresult ;
28162   Dali::RenderTask *result = 0 ;
28163
28164   {
28165     try {
28166       result = (Dali::RenderTask *)new Dali::RenderTask();
28167     } catch (std::out_of_range& e) {
28168       {
28169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28170       };
28171     } catch (std::exception& e) {
28172       {
28173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28174       };
28175     } catch (Dali::DaliException e) {
28176       {
28177         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28178       };
28179     } catch (...) {
28180       {
28181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28182       };
28183     }
28184   }
28185
28186   jresult = (void *)result;
28187   return jresult;
28188 }
28189
28190
28191 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DownCast(void * jarg1) {
28192   void * jresult ;
28193   Dali::BaseHandle arg1 ;
28194   Dali::BaseHandle *argp1 ;
28195   Dali::RenderTask result;
28196
28197   argp1 = (Dali::BaseHandle *)jarg1;
28198   if (!argp1) {
28199     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
28200     return 0;
28201   }
28202   arg1 = *argp1;
28203   {
28204     try {
28205       result = Dali::RenderTask::DownCast(arg1);
28206     } catch (std::out_of_range& e) {
28207       {
28208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28209       };
28210     } catch (std::exception& e) {
28211       {
28212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28213       };
28214     } catch (Dali::DaliException e) {
28215       {
28216         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28217       };
28218     } catch (...) {
28219       {
28220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28221       };
28222     }
28223   }
28224
28225   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
28226   return jresult;
28227 }
28228
28229
28230 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask(void * jarg1) {
28231   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28232
28233   arg1 = (Dali::RenderTask *)jarg1;
28234   {
28235     try {
28236       delete arg1;
28237     } catch (std::out_of_range& e) {
28238       {
28239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28240       };
28241     } catch (std::exception& e) {
28242       {
28243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28244       };
28245     } catch (Dali::DaliException e) {
28246       {
28247         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28248       };
28249     } catch (...) {
28250       {
28251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28252       };
28253     }
28254   }
28255
28256 }
28257
28258
28259 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_1(void * jarg1) {
28260   void * jresult ;
28261   Dali::RenderTask *arg1 = 0 ;
28262   Dali::RenderTask *result = 0 ;
28263
28264   arg1 = (Dali::RenderTask *)jarg1;
28265   if (!arg1) {
28266     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
28267     return 0;
28268   }
28269   {
28270     try {
28271       result = (Dali::RenderTask *)new Dali::RenderTask((Dali::RenderTask const &)*arg1);
28272     } catch (std::out_of_range& e) {
28273       {
28274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28275       };
28276     } catch (std::exception& e) {
28277       {
28278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28279       };
28280     } catch (Dali::DaliException e) {
28281       {
28282         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28283       };
28284     } catch (...) {
28285       {
28286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28287       };
28288     }
28289   }
28290
28291   jresult = (void *)result;
28292   return jresult;
28293 }
28294
28295
28296 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_Assign(void * jarg1, void * jarg2) {
28297   void * jresult ;
28298   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28299   Dali::RenderTask *arg2 = 0 ;
28300   Dali::RenderTask *result = 0 ;
28301
28302   arg1 = (Dali::RenderTask *)jarg1;
28303   arg2 = (Dali::RenderTask *)jarg2;
28304   if (!arg2) {
28305     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
28306     return 0;
28307   }
28308   {
28309     try {
28310       result = (Dali::RenderTask *) &(arg1)->operator =((Dali::RenderTask const &)*arg2);
28311     } catch (std::out_of_range& e) {
28312       {
28313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28314       };
28315     } catch (std::exception& e) {
28316       {
28317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28318       };
28319     } catch (Dali::DaliException e) {
28320       {
28321         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28322       };
28323     } catch (...) {
28324       {
28325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28326       };
28327     }
28328   }
28329
28330   jresult = (void *)result;
28331   return jresult;
28332 }
28333
28334
28335 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetSourceActor(void * jarg1, void * jarg2) {
28336   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28337   Dali::Actor arg2 ;
28338   Dali::Actor *argp2 ;
28339
28340   arg1 = (Dali::RenderTask *)jarg1;
28341   argp2 = (Dali::Actor *)jarg2;
28342   if (!argp2) {
28343     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28344     return ;
28345   }
28346   arg2 = *argp2;
28347   {
28348     try {
28349       (arg1)->SetSourceActor(arg2);
28350     } catch (std::out_of_range& e) {
28351       {
28352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28353       };
28354     } catch (std::exception& e) {
28355       {
28356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28357       };
28358     } catch (Dali::DaliException e) {
28359       {
28360         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28361       };
28362     } catch (...) {
28363       {
28364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28365       };
28366     }
28367   }
28368
28369 }
28370
28371
28372 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetSourceActor(void * jarg1) {
28373   void * jresult ;
28374   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28375   Dali::Actor result;
28376
28377   arg1 = (Dali::RenderTask *)jarg1;
28378   {
28379     try {
28380       result = ((Dali::RenderTask const *)arg1)->GetSourceActor();
28381     } catch (std::out_of_range& e) {
28382       {
28383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28384       };
28385     } catch (std::exception& e) {
28386       {
28387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28388       };
28389     } catch (Dali::DaliException e) {
28390       {
28391         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28392       };
28393     } catch (...) {
28394       {
28395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28396       };
28397     }
28398   }
28399
28400   jresult = new Dali::Actor((const Dali::Actor &)result);
28401   return jresult;
28402 }
28403
28404
28405 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetExclusive(void * jarg1, unsigned int jarg2) {
28406   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28407   bool arg2 ;
28408
28409   arg1 = (Dali::RenderTask *)jarg1;
28410   arg2 = jarg2 ? true : false;
28411   {
28412     try {
28413       (arg1)->SetExclusive(arg2);
28414     } catch (std::out_of_range& e) {
28415       {
28416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28417       };
28418     } catch (std::exception& e) {
28419       {
28420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28421       };
28422     } catch (Dali::DaliException e) {
28423       {
28424         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28425       };
28426     } catch (...) {
28427       {
28428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28429       };
28430     }
28431   }
28432
28433 }
28434
28435
28436 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_IsExclusive(void * jarg1) {
28437   unsigned int jresult ;
28438   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28439   bool result;
28440
28441   arg1 = (Dali::RenderTask *)jarg1;
28442   {
28443     try {
28444       result = (bool)((Dali::RenderTask const *)arg1)->IsExclusive();
28445     } catch (std::out_of_range& e) {
28446       {
28447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28448       };
28449     } catch (std::exception& e) {
28450       {
28451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28452       };
28453     } catch (Dali::DaliException e) {
28454       {
28455         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28456       };
28457     } catch (...) {
28458       {
28459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28460       };
28461     }
28462   }
28463
28464   jresult = result;
28465   return jresult;
28466 }
28467
28468
28469 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetInputEnabled(void * jarg1, unsigned int jarg2) {
28470   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28471   bool arg2 ;
28472
28473   arg1 = (Dali::RenderTask *)jarg1;
28474   arg2 = jarg2 ? true : false;
28475   {
28476     try {
28477       (arg1)->SetInputEnabled(arg2);
28478     } catch (std::out_of_range& e) {
28479       {
28480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28481       };
28482     } catch (std::exception& e) {
28483       {
28484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28485       };
28486     } catch (Dali::DaliException e) {
28487       {
28488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28489       };
28490     } catch (...) {
28491       {
28492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28493       };
28494     }
28495   }
28496
28497 }
28498
28499
28500 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetInputEnabled(void * jarg1) {
28501   unsigned int jresult ;
28502   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28503   bool result;
28504
28505   arg1 = (Dali::RenderTask *)jarg1;
28506   {
28507     try {
28508       result = (bool)((Dali::RenderTask const *)arg1)->GetInputEnabled();
28509     } catch (std::out_of_range& e) {
28510       {
28511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28512       };
28513     } catch (std::exception& e) {
28514       {
28515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28516       };
28517     } catch (Dali::DaliException e) {
28518       {
28519         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28520       };
28521     } catch (...) {
28522       {
28523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28524       };
28525     }
28526   }
28527
28528   jresult = result;
28529   return jresult;
28530 }
28531
28532
28533 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCameraActor(void * jarg1, void * jarg2) {
28534   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28535   Dali::CameraActor arg2 ;
28536   Dali::CameraActor *argp2 ;
28537
28538   arg1 = (Dali::RenderTask *)jarg1;
28539   argp2 = (Dali::CameraActor *)jarg2;
28540   if (!argp2) {
28541     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::CameraActor", 0);
28542     return ;
28543   }
28544   arg2 = *argp2;
28545   {
28546     try {
28547       (arg1)->SetCameraActor(arg2);
28548     } catch (std::out_of_range& e) {
28549       {
28550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28551       };
28552     } catch (std::exception& e) {
28553       {
28554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28555       };
28556     } catch (Dali::DaliException e) {
28557       {
28558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28559       };
28560     } catch (...) {
28561       {
28562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28563       };
28564     }
28565   }
28566
28567 }
28568
28569
28570 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCameraActor(void * jarg1) {
28571   void * jresult ;
28572   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28573   Dali::CameraActor result;
28574
28575   arg1 = (Dali::RenderTask *)jarg1;
28576   {
28577     try {
28578       result = ((Dali::RenderTask const *)arg1)->GetCameraActor();
28579     } catch (std::out_of_range& e) {
28580       {
28581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28582       };
28583     } catch (std::exception& e) {
28584       {
28585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28586       };
28587     } catch (Dali::DaliException e) {
28588       {
28589         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28590       };
28591     } catch (...) {
28592       {
28593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28594       };
28595     }
28596   }
28597
28598   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
28599   return jresult;
28600 }
28601
28602
28603 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetTargetFrameBuffer(void * jarg1, void * jarg2) {
28604   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28605   Dali::FrameBufferImage arg2 ;
28606   Dali::FrameBufferImage *argp2 ;
28607
28608   arg1 = (Dali::RenderTask *)jarg1;
28609   argp2 = (Dali::FrameBufferImage *)jarg2;
28610   if (!argp2) {
28611     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBufferImage", 0);
28612     return ;
28613   }
28614   arg2 = *argp2;
28615   {
28616     try {
28617       (arg1)->SetTargetFrameBuffer(arg2);
28618     } catch (std::out_of_range& e) {
28619       {
28620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28621       };
28622     } catch (std::exception& e) {
28623       {
28624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28625       };
28626     } catch (Dali::DaliException e) {
28627       {
28628         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28629       };
28630     } catch (...) {
28631       {
28632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28633       };
28634     }
28635   }
28636
28637 }
28638
28639
28640 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetTargetFrameBuffer(void * jarg1) {
28641   void * jresult ;
28642   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28643   Dali::FrameBufferImage result;
28644
28645   arg1 = (Dali::RenderTask *)jarg1;
28646   {
28647     try {
28648       result = ((Dali::RenderTask const *)arg1)->GetTargetFrameBuffer();
28649     } catch (std::out_of_range& e) {
28650       {
28651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28652       };
28653     } catch (std::exception& e) {
28654       {
28655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28656       };
28657     } catch (Dali::DaliException e) {
28658       {
28659         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28660       };
28661     } catch (...) {
28662       {
28663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28664       };
28665     }
28666   }
28667
28668   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
28669   return jresult;
28670 }
28671
28672
28673 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetFrameBuffer(void * jarg1, void * jarg2) {
28674   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28675   Dali::FrameBuffer arg2 ;
28676   Dali::FrameBuffer *argp2 ;
28677
28678   arg1 = (Dali::RenderTask *)jarg1;
28679   argp2 = (Dali::FrameBuffer *)jarg2;
28680   if (!argp2) {
28681     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBuffer", 0);
28682     return ;
28683   }
28684   arg2 = *argp2;
28685   {
28686     try {
28687       (arg1)->SetFrameBuffer(arg2);
28688     } catch (std::out_of_range& e) {
28689       {
28690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28691       };
28692     } catch (std::exception& e) {
28693       {
28694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28695       };
28696     } catch (Dali::DaliException e) {
28697       {
28698         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28699       };
28700     } catch (...) {
28701       {
28702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28703       };
28704     }
28705   }
28706
28707 }
28708
28709
28710 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetFrameBuffer(void * jarg1) {
28711   void * jresult ;
28712   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28713   Dali::FrameBuffer result;
28714
28715   arg1 = (Dali::RenderTask *)jarg1;
28716   {
28717     try {
28718       result = ((Dali::RenderTask const *)arg1)->GetFrameBuffer();
28719     } catch (std::out_of_range& e) {
28720       {
28721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28722       };
28723     } catch (std::exception& e) {
28724       {
28725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28726       };
28727     } catch (Dali::DaliException e) {
28728       {
28729         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28730       };
28731     } catch (...) {
28732       {
28733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28734       };
28735     }
28736   }
28737
28738   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
28739   return jresult;
28740 }
28741
28742
28743 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferFunction(void * jarg1, void * jarg2) {
28744   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28745   Dali::RenderTask::ScreenToFrameBufferFunction arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction) 0 ;
28746
28747   arg1 = (Dali::RenderTask *)jarg1;
28748   arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction)jarg2;
28749   {
28750     try {
28751       (arg1)->SetScreenToFrameBufferFunction(arg2);
28752     } catch (std::out_of_range& e) {
28753       {
28754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28755       };
28756     } catch (std::exception& e) {
28757       {
28758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28759       };
28760     } catch (Dali::DaliException e) {
28761       {
28762         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28763       };
28764     } catch (...) {
28765       {
28766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28767       };
28768     }
28769   }
28770
28771 }
28772
28773
28774 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferFunction(void * jarg1) {
28775   void * jresult ;
28776   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28777   Dali::RenderTask::ScreenToFrameBufferFunction result;
28778
28779   arg1 = (Dali::RenderTask *)jarg1;
28780   {
28781     try {
28782       result = (Dali::RenderTask::ScreenToFrameBufferFunction)((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferFunction();
28783     } catch (std::out_of_range& e) {
28784       {
28785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28786       };
28787     } catch (std::exception& e) {
28788       {
28789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28790       };
28791     } catch (Dali::DaliException e) {
28792       {
28793         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28794       };
28795     } catch (...) {
28796       {
28797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28798       };
28799     }
28800   }
28801
28802   jresult = (void *)result;
28803   return jresult;
28804 }
28805
28806
28807 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferMappingActor(void * jarg1, void * jarg2) {
28808   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28809   Dali::Actor arg2 ;
28810   Dali::Actor *argp2 ;
28811
28812   arg1 = (Dali::RenderTask *)jarg1;
28813   argp2 = (Dali::Actor *)jarg2;
28814   if (!argp2) {
28815     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28816     return ;
28817   }
28818   arg2 = *argp2;
28819   {
28820     try {
28821       (arg1)->SetScreenToFrameBufferMappingActor(arg2);
28822     } catch (std::out_of_range& e) {
28823       {
28824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28825       };
28826     } catch (std::exception& e) {
28827       {
28828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28829       };
28830     } catch (Dali::DaliException e) {
28831       {
28832         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28833       };
28834     } catch (...) {
28835       {
28836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28837       };
28838     }
28839   }
28840
28841 }
28842
28843
28844 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferMappingActor(void * jarg1) {
28845   void * jresult ;
28846   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28847   Dali::Actor result;
28848
28849   arg1 = (Dali::RenderTask *)jarg1;
28850   {
28851     try {
28852       result = ((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferMappingActor();
28853     } catch (std::out_of_range& e) {
28854       {
28855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28856       };
28857     } catch (std::exception& e) {
28858       {
28859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28860       };
28861     } catch (Dali::DaliException e) {
28862       {
28863         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28864       };
28865     } catch (...) {
28866       {
28867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28868       };
28869     }
28870   }
28871
28872   jresult = new Dali::Actor((const Dali::Actor &)result);
28873   return jresult;
28874 }
28875
28876
28877 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportPosition(void * jarg1, void * jarg2) {
28878   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28879   Dali::Vector2 arg2 ;
28880   Dali::Vector2 *argp2 ;
28881
28882   arg1 = (Dali::RenderTask *)jarg1;
28883   argp2 = (Dali::Vector2 *)jarg2;
28884   if (!argp2) {
28885     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
28886     return ;
28887   }
28888   arg2 = *argp2;
28889   {
28890     try {
28891       (arg1)->SetViewportPosition(arg2);
28892     } catch (std::out_of_range& e) {
28893       {
28894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28895       };
28896     } catch (std::exception& e) {
28897       {
28898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28899       };
28900     } catch (Dali::DaliException e) {
28901       {
28902         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28903       };
28904     } catch (...) {
28905       {
28906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28907       };
28908     }
28909   }
28910
28911 }
28912
28913
28914 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportPosition(void * jarg1) {
28915   void * jresult ;
28916   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28917   Dali::Vector2 result;
28918
28919   arg1 = (Dali::RenderTask *)jarg1;
28920   {
28921     try {
28922       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportPosition();
28923     } catch (std::out_of_range& e) {
28924       {
28925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28926       };
28927     } catch (std::exception& e) {
28928       {
28929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28930       };
28931     } catch (Dali::DaliException e) {
28932       {
28933         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28934       };
28935     } catch (...) {
28936       {
28937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28938       };
28939     }
28940   }
28941
28942   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
28943   return jresult;
28944 }
28945
28946
28947 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportSize(void * jarg1, void * jarg2) {
28948   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28949   Dali::Vector2 arg2 ;
28950   Dali::Vector2 *argp2 ;
28951
28952   arg1 = (Dali::RenderTask *)jarg1;
28953   argp2 = (Dali::Vector2 *)jarg2;
28954   if (!argp2) {
28955     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
28956     return ;
28957   }
28958   arg2 = *argp2;
28959   {
28960     try {
28961       (arg1)->SetViewportSize(arg2);
28962     } catch (std::out_of_range& e) {
28963       {
28964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28965       };
28966     } catch (std::exception& e) {
28967       {
28968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28969       };
28970     } catch (Dali::DaliException e) {
28971       {
28972         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28973       };
28974     } catch (...) {
28975       {
28976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28977       };
28978     }
28979   }
28980
28981 }
28982
28983
28984 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportSize(void * jarg1) {
28985   void * jresult ;
28986   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28987   Dali::Vector2 result;
28988
28989   arg1 = (Dali::RenderTask *)jarg1;
28990   {
28991     try {
28992       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportSize();
28993     } catch (std::out_of_range& e) {
28994       {
28995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28996       };
28997     } catch (std::exception& e) {
28998       {
28999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29000       };
29001     } catch (Dali::DaliException e) {
29002       {
29003         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29004       };
29005     } catch (...) {
29006       {
29007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29008       };
29009     }
29010   }
29011
29012   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
29013   return jresult;
29014 }
29015
29016
29017 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewport(void * jarg1, void * jarg2) {
29018   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29019   Dali::Viewport arg2 ;
29020   Dali::Viewport *argp2 ;
29021
29022   arg1 = (Dali::RenderTask *)jarg1;
29023   argp2 = (Dali::Viewport *)jarg2;
29024   if (!argp2) {
29025     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Viewport", 0);
29026     return ;
29027   }
29028   arg2 = *argp2;
29029   {
29030     try {
29031       (arg1)->SetViewport(arg2);
29032     } catch (std::out_of_range& e) {
29033       {
29034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29035       };
29036     } catch (std::exception& e) {
29037       {
29038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29039       };
29040     } catch (Dali::DaliException e) {
29041       {
29042         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29043       };
29044     } catch (...) {
29045       {
29046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29047       };
29048     }
29049   }
29050
29051 }
29052
29053
29054 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetViewport(void * jarg1) {
29055   void * jresult ;
29056   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29057   Dali::Viewport result;
29058
29059   arg1 = (Dali::RenderTask *)jarg1;
29060   {
29061     try {
29062       result = ((Dali::RenderTask const *)arg1)->GetViewport();
29063     } catch (std::out_of_range& e) {
29064       {
29065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29066       };
29067     } catch (std::exception& e) {
29068       {
29069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29070       };
29071     } catch (Dali::DaliException e) {
29072       {
29073         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29074       };
29075     } catch (...) {
29076       {
29077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29078       };
29079     }
29080   }
29081
29082   jresult = new Dali::Viewport((const Dali::Viewport &)result);
29083   return jresult;
29084 }
29085
29086
29087 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearColor(void * jarg1, void * jarg2) {
29088   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29089   Dali::Vector4 *arg2 = 0 ;
29090
29091   arg1 = (Dali::RenderTask *)jarg1;
29092   arg2 = (Dali::Vector4 *)jarg2;
29093   if (!arg2) {
29094     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
29095     return ;
29096   }
29097   {
29098     try {
29099       (arg1)->SetClearColor((Dali::Vector4 const &)*arg2);
29100     } catch (std::out_of_range& e) {
29101       {
29102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29103       };
29104     } catch (std::exception& e) {
29105       {
29106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29107       };
29108     } catch (Dali::DaliException e) {
29109       {
29110         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29111       };
29112     } catch (...) {
29113       {
29114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29115       };
29116     }
29117   }
29118
29119 }
29120
29121
29122 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetClearColor(void * jarg1) {
29123   void * jresult ;
29124   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29125   Dali::Vector4 result;
29126
29127   arg1 = (Dali::RenderTask *)jarg1;
29128   {
29129     try {
29130       result = ((Dali::RenderTask const *)arg1)->GetClearColor();
29131     } catch (std::out_of_range& e) {
29132       {
29133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29134       };
29135     } catch (std::exception& e) {
29136       {
29137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29138       };
29139     } catch (Dali::DaliException e) {
29140       {
29141         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29142       };
29143     } catch (...) {
29144       {
29145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29146       };
29147     }
29148   }
29149
29150   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
29151   return jresult;
29152 }
29153
29154
29155 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearEnabled(void * jarg1, unsigned int jarg2) {
29156   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29157   bool arg2 ;
29158
29159   arg1 = (Dali::RenderTask *)jarg1;
29160   arg2 = jarg2 ? true : false;
29161   {
29162     try {
29163       (arg1)->SetClearEnabled(arg2);
29164     } catch (std::out_of_range& e) {
29165       {
29166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29167       };
29168     } catch (std::exception& e) {
29169       {
29170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29171       };
29172     } catch (Dali::DaliException e) {
29173       {
29174         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29175       };
29176     } catch (...) {
29177       {
29178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29179       };
29180     }
29181   }
29182
29183 }
29184
29185
29186 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetClearEnabled(void * jarg1) {
29187   unsigned int jresult ;
29188   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29189   bool result;
29190
29191   arg1 = (Dali::RenderTask *)jarg1;
29192   {
29193     try {
29194       result = (bool)((Dali::RenderTask const *)arg1)->GetClearEnabled();
29195     } catch (std::out_of_range& e) {
29196       {
29197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29198       };
29199     } catch (std::exception& e) {
29200       {
29201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29202       };
29203     } catch (Dali::DaliException e) {
29204       {
29205         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29206       };
29207     } catch (...) {
29208       {
29209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29210       };
29211     }
29212   }
29213
29214   jresult = result;
29215   return jresult;
29216 }
29217
29218
29219 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCullMode(void * jarg1, unsigned int jarg2) {
29220   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29221   bool arg2 ;
29222
29223   arg1 = (Dali::RenderTask *)jarg1;
29224   arg2 = jarg2 ? true : false;
29225   {
29226     try {
29227       (arg1)->SetCullMode(arg2);
29228     } catch (std::out_of_range& e) {
29229       {
29230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29231       };
29232     } catch (std::exception& e) {
29233       {
29234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29235       };
29236     } catch (Dali::DaliException e) {
29237       {
29238         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29239       };
29240     } catch (...) {
29241       {
29242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29243       };
29244     }
29245   }
29246
29247 }
29248
29249
29250 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetCullMode(void * jarg1) {
29251   unsigned int jresult ;
29252   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29253   bool result;
29254
29255   arg1 = (Dali::RenderTask *)jarg1;
29256   {
29257     try {
29258       result = (bool)((Dali::RenderTask const *)arg1)->GetCullMode();
29259     } catch (std::out_of_range& e) {
29260       {
29261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29262       };
29263     } catch (std::exception& e) {
29264       {
29265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29266       };
29267     } catch (Dali::DaliException e) {
29268       {
29269         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29270       };
29271     } catch (...) {
29272       {
29273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29274       };
29275     }
29276   }
29277
29278   jresult = result;
29279   return jresult;
29280 }
29281
29282
29283 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetRefreshRate(void * jarg1, unsigned int jarg2) {
29284   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29285   unsigned int arg2 ;
29286
29287   arg1 = (Dali::RenderTask *)jarg1;
29288   arg2 = (unsigned int)jarg2;
29289   {
29290     try {
29291       (arg1)->SetRefreshRate(arg2);
29292     } catch (std::out_of_range& e) {
29293       {
29294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29295       };
29296     } catch (std::exception& e) {
29297       {
29298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29299       };
29300     } catch (Dali::DaliException e) {
29301       {
29302         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29303       };
29304     } catch (...) {
29305       {
29306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29307       };
29308     }
29309   }
29310
29311 }
29312
29313
29314 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetRefreshRate(void * jarg1) {
29315   unsigned int jresult ;
29316   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29317   unsigned int result;
29318
29319   arg1 = (Dali::RenderTask *)jarg1;
29320   {
29321     try {
29322       result = (unsigned int)((Dali::RenderTask const *)arg1)->GetRefreshRate();
29323     } catch (std::out_of_range& e) {
29324       {
29325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29326       };
29327     } catch (std::exception& e) {
29328       {
29329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29330       };
29331     } catch (Dali::DaliException e) {
29332       {
29333         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29334       };
29335     } catch (...) {
29336       {
29337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29338       };
29339     }
29340   }
29341
29342   jresult = result;
29343   return jresult;
29344 }
29345
29346
29347 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_WorldToViewport(void * jarg1, void * jarg2, float * jarg3, float * jarg4) {
29348   unsigned int jresult ;
29349   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29350   Dali::Vector3 *arg2 = 0 ;
29351   float *arg3 = 0 ;
29352   float *arg4 = 0 ;
29353   bool result;
29354
29355   arg1 = (Dali::RenderTask *)jarg1;
29356   arg2 = (Dali::Vector3 *)jarg2;
29357   if (!arg2) {
29358     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
29359     return 0;
29360   }
29361   arg3 = (float *)jarg3;
29362   arg4 = (float *)jarg4;
29363   {
29364     try {
29365       result = (bool)((Dali::RenderTask const *)arg1)->WorldToViewport((Dali::Vector3 const &)*arg2,*arg3,*arg4);
29366     } catch (std::out_of_range& e) {
29367       {
29368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29369       };
29370     } catch (std::exception& e) {
29371       {
29372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29373       };
29374     } catch (Dali::DaliException e) {
29375       {
29376         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29377       };
29378     } catch (...) {
29379       {
29380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29381       };
29382     }
29383   }
29384
29385   jresult = result;
29386   return jresult;
29387 }
29388
29389
29390 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_ViewportToLocal(void * jarg1, void * jarg2, float jarg3, float jarg4, float * jarg5, float * jarg6) {
29391   unsigned int jresult ;
29392   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29393   Dali::Actor arg2 ;
29394   float arg3 ;
29395   float arg4 ;
29396   float *arg5 = 0 ;
29397   float *arg6 = 0 ;
29398   Dali::Actor *argp2 ;
29399   bool result;
29400
29401   arg1 = (Dali::RenderTask *)jarg1;
29402   argp2 = (Dali::Actor *)jarg2;
29403   if (!argp2) {
29404     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
29405     return 0;
29406   }
29407   arg2 = *argp2;
29408   arg3 = (float)jarg3;
29409   arg4 = (float)jarg4;
29410   arg5 = (float *)jarg5;
29411   arg6 = (float *)jarg6;
29412   {
29413     try {
29414       result = (bool)((Dali::RenderTask const *)arg1)->ViewportToLocal(arg2,arg3,arg4,*arg5,*arg6);
29415     } catch (std::out_of_range& e) {
29416       {
29417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29418       };
29419     } catch (std::exception& e) {
29420       {
29421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29422       };
29423     } catch (Dali::DaliException e) {
29424       {
29425         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29426       };
29427     } catch (...) {
29428       {
29429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29430       };
29431     }
29432   }
29433
29434   jresult = result;
29435   return jresult;
29436 }
29437
29438
29439 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FinishedSignal(void * jarg1) {
29440   void * jresult ;
29441   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29442   Dali::RenderTask::RenderTaskSignalType *result = 0 ;
29443
29444   arg1 = (Dali::RenderTask *)jarg1;
29445   {
29446     try {
29447       result = (Dali::RenderTask::RenderTaskSignalType *) &(arg1)->FinishedSignal();
29448     } catch (std::out_of_range& e) {
29449       {
29450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29451       };
29452     } catch (std::exception& e) {
29453       {
29454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29455       };
29456     } catch (Dali::DaliException e) {
29457       {
29458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29459       };
29460     } catch (...) {
29461       {
29462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29463       };
29464     }
29465   }
29466
29467   jresult = (void *)result;
29468   return jresult;
29469 }
29470
29471
29472 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_0(int jarg1, int jarg2, float jarg3, float jarg4) {
29473   void * jresult ;
29474   int arg1 ;
29475   Dali::TouchPoint::State arg2 ;
29476   float arg3 ;
29477   float arg4 ;
29478   Dali::TouchPoint *result = 0 ;
29479
29480   arg1 = (int)jarg1;
29481   arg2 = (Dali::TouchPoint::State)jarg2;
29482   arg3 = (float)jarg3;
29483   arg4 = (float)jarg4;
29484   {
29485     try {
29486       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4);
29487     } catch (std::out_of_range& e) {
29488       {
29489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29490       };
29491     } catch (std::exception& e) {
29492       {
29493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29494       };
29495     } catch (Dali::DaliException e) {
29496       {
29497         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29498       };
29499     } catch (...) {
29500       {
29501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29502       };
29503     }
29504   }
29505
29506   jresult = (void *)result;
29507   return jresult;
29508 }
29509
29510
29511 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_1(int jarg1, int jarg2, float jarg3, float jarg4, float jarg5, float jarg6) {
29512   void * jresult ;
29513   int arg1 ;
29514   Dali::TouchPoint::State arg2 ;
29515   float arg3 ;
29516   float arg4 ;
29517   float arg5 ;
29518   float arg6 ;
29519   Dali::TouchPoint *result = 0 ;
29520
29521   arg1 = (int)jarg1;
29522   arg2 = (Dali::TouchPoint::State)jarg2;
29523   arg3 = (float)jarg3;
29524   arg4 = (float)jarg4;
29525   arg5 = (float)jarg5;
29526   arg6 = (float)jarg6;
29527   {
29528     try {
29529       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4,arg5,arg6);
29530     } catch (std::out_of_range& e) {
29531       {
29532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29533       };
29534     } catch (std::exception& e) {
29535       {
29536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29537       };
29538     } catch (Dali::DaliException e) {
29539       {
29540         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29541       };
29542     } catch (...) {
29543       {
29544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29545       };
29546     }
29547   }
29548
29549   jresult = (void *)result;
29550   return jresult;
29551 }
29552
29553
29554 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPoint(void * jarg1) {
29555   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29556
29557   arg1 = (Dali::TouchPoint *)jarg1;
29558   {
29559     try {
29560       delete arg1;
29561     } catch (std::out_of_range& e) {
29562       {
29563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29564       };
29565     } catch (std::exception& e) {
29566       {
29567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29568       };
29569     } catch (Dali::DaliException e) {
29570       {
29571         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29572       };
29573     } catch (...) {
29574       {
29575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29576       };
29577     }
29578   }
29579
29580 }
29581
29582
29583 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_set(void * jarg1, int jarg2) {
29584   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29585   int arg2 ;
29586
29587   arg1 = (Dali::TouchPoint *)jarg1;
29588   arg2 = (int)jarg2;
29589   if (arg1) (arg1)->deviceId = arg2;
29590 }
29591
29592
29593 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_get(void * jarg1) {
29594   int jresult ;
29595   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29596   int result;
29597
29598   arg1 = (Dali::TouchPoint *)jarg1;
29599   result = (int) ((arg1)->deviceId);
29600   jresult = result;
29601   return jresult;
29602 }
29603
29604
29605 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_state_set(void * jarg1, int jarg2) {
29606   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29607   Dali::TouchPoint::State arg2 ;
29608
29609   arg1 = (Dali::TouchPoint *)jarg1;
29610   arg2 = (Dali::TouchPoint::State)jarg2;
29611   if (arg1) (arg1)->state = arg2;
29612 }
29613
29614
29615 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_state_get(void * jarg1) {
29616   int jresult ;
29617   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29618   Dali::TouchPoint::State result;
29619
29620   arg1 = (Dali::TouchPoint *)jarg1;
29621   result = (Dali::TouchPoint::State) ((arg1)->state);
29622   jresult = (int)result;
29623   return jresult;
29624 }
29625
29626
29627 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_set(void * jarg1, void * jarg2) {
29628   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29629   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
29630
29631   arg1 = (Dali::TouchPoint *)jarg1;
29632   arg2 = (Dali::Actor *)jarg2;
29633   if (arg1) (arg1)->hitActor = *arg2;
29634 }
29635
29636
29637 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_get(void * jarg1) {
29638   void * jresult ;
29639   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29640   Dali::Actor *result = 0 ;
29641
29642   arg1 = (Dali::TouchPoint *)jarg1;
29643   result = (Dali::Actor *)& ((arg1)->hitActor);
29644   jresult = (void *)result;
29645   return jresult;
29646 }
29647
29648
29649 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_local_set(void * jarg1, void * jarg2) {
29650   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29651   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
29652
29653   arg1 = (Dali::TouchPoint *)jarg1;
29654   arg2 = (Dali::Vector2 *)jarg2;
29655   if (arg1) (arg1)->local = *arg2;
29656 }
29657
29658
29659 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_local_get(void * jarg1) {
29660   void * jresult ;
29661   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29662   Dali::Vector2 *result = 0 ;
29663
29664   arg1 = (Dali::TouchPoint *)jarg1;
29665   result = (Dali::Vector2 *)& ((arg1)->local);
29666   jresult = (void *)result;
29667   return jresult;
29668 }
29669
29670
29671 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_screen_set(void * jarg1, void * jarg2) {
29672   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29673   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
29674
29675   arg1 = (Dali::TouchPoint *)jarg1;
29676   arg2 = (Dali::Vector2 *)jarg2;
29677   if (arg1) (arg1)->screen = *arg2;
29678 }
29679
29680
29681 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_screen_get(void * jarg1) {
29682   void * jresult ;
29683   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29684   Dali::Vector2 *result = 0 ;
29685
29686   arg1 = (Dali::TouchPoint *)jarg1;
29687   result = (Dali::Vector2 *)& ((arg1)->screen);
29688   jresult = (void *)result;
29689   return jresult;
29690 }
29691
29692
29693 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_0() {
29694   void * jresult ;
29695   Dali::TouchData *result = 0 ;
29696
29697   {
29698     try {
29699       result = (Dali::TouchData *)new Dali::TouchData();
29700     } catch (std::out_of_range& e) {
29701       {
29702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29703       };
29704     } catch (std::exception& e) {
29705       {
29706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29707       };
29708     } catch (Dali::DaliException e) {
29709       {
29710         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29711       };
29712     } catch (...) {
29713       {
29714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29715       };
29716     }
29717   }
29718
29719   jresult = (void *)result;
29720   return jresult;
29721 }
29722
29723
29724 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_1(void * jarg1) {
29725   void * jresult ;
29726   Dali::TouchData *arg1 = 0 ;
29727   Dali::TouchData *result = 0 ;
29728
29729   arg1 = (Dali::TouchData *)jarg1;
29730   if (!arg1) {
29731     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
29732     return 0;
29733   }
29734   {
29735     try {
29736       result = (Dali::TouchData *)new Dali::TouchData((Dali::TouchData const &)*arg1);
29737     } catch (std::out_of_range& e) {
29738       {
29739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29740       };
29741     } catch (std::exception& e) {
29742       {
29743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29744       };
29745     } catch (Dali::DaliException e) {
29746       {
29747         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29748       };
29749     } catch (...) {
29750       {
29751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29752       };
29753     }
29754   }
29755
29756   jresult = (void *)result;
29757   return jresult;
29758 }
29759
29760
29761 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Touch(void * jarg1) {
29762   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29763
29764   arg1 = (Dali::TouchData *)jarg1;
29765   {
29766     try {
29767       delete arg1;
29768     } catch (std::out_of_range& e) {
29769       {
29770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29771       };
29772     } catch (std::exception& e) {
29773       {
29774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29775       };
29776     } catch (Dali::DaliException e) {
29777       {
29778         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29779       };
29780     } catch (...) {
29781       {
29782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29783       };
29784     }
29785   }
29786
29787 }
29788
29789
29790 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_Assign(void * jarg1, void * jarg2) {
29791   void * jresult ;
29792   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29793   Dali::TouchData *arg2 = 0 ;
29794   Dali::TouchData *result = 0 ;
29795
29796   arg1 = (Dali::TouchData *)jarg1;
29797   arg2 = (Dali::TouchData *)jarg2;
29798   if (!arg2) {
29799     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
29800     return 0;
29801   }
29802   {
29803     try {
29804       result = (Dali::TouchData *) &(arg1)->operator =((Dali::TouchData const &)*arg2);
29805     } catch (std::out_of_range& e) {
29806       {
29807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29808       };
29809     } catch (std::exception& e) {
29810       {
29811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29812       };
29813     } catch (Dali::DaliException e) {
29814       {
29815         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29816       };
29817     } catch (...) {
29818       {
29819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29820       };
29821     }
29822   }
29823
29824   jresult = (void *)result;
29825   return jresult;
29826 }
29827
29828
29829 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetTime(void * jarg1) {
29830   unsigned long jresult ;
29831   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29832   unsigned long result;
29833
29834   arg1 = (Dali::TouchData *)jarg1;
29835   {
29836     try {
29837       result = (unsigned long)((Dali::TouchData const *)arg1)->GetTime();
29838     } catch (std::out_of_range& e) {
29839       {
29840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29841       };
29842     } catch (std::exception& e) {
29843       {
29844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29845       };
29846     } catch (Dali::DaliException e) {
29847       {
29848         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29849       };
29850     } catch (...) {
29851       {
29852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29853       };
29854     }
29855   }
29856
29857   jresult = (unsigned long)result;
29858   return jresult;
29859 }
29860
29861
29862 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetPointCount(void * jarg1) {
29863   unsigned long jresult ;
29864   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29865   std::size_t result;
29866
29867   arg1 = (Dali::TouchData *)jarg1;
29868   {
29869     try {
29870       result = ((Dali::TouchData const *)arg1)->GetPointCount();
29871     } catch (std::out_of_range& e) {
29872       {
29873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29874       };
29875     } catch (std::exception& e) {
29876       {
29877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29878       };
29879     } catch (Dali::DaliException e) {
29880       {
29881         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29882       };
29883     } catch (...) {
29884       {
29885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29886       };
29887     }
29888   }
29889
29890   jresult = (unsigned long)result;
29891   return jresult;
29892 }
29893
29894
29895 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetDeviceId(void * jarg1, unsigned long jarg2) {
29896   int jresult ;
29897   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29898   std::size_t arg2 ;
29899   int32_t result;
29900
29901   arg1 = (Dali::TouchData *)jarg1;
29902   arg2 = (std::size_t)jarg2;
29903   {
29904     try {
29905       result = ((Dali::TouchData const *)arg1)->GetDeviceId(arg2);
29906     } catch (std::out_of_range& e) {
29907       {
29908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29909       };
29910     } catch (std::exception& e) {
29911       {
29912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29913       };
29914     } catch (Dali::DaliException e) {
29915       {
29916         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29917       };
29918     } catch (...) {
29919       {
29920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29921       };
29922     }
29923   }
29924
29925   jresult = result;
29926   return jresult;
29927 }
29928
29929
29930 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetState(void * jarg1, unsigned long jarg2) {
29931   int jresult ;
29932   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29933   std::size_t arg2 ;
29934   Dali::PointState::Type result;
29935
29936   arg1 = (Dali::TouchData *)jarg1;
29937   arg2 = (std::size_t)jarg2;
29938   {
29939     try {
29940       result = (Dali::PointState::Type)((Dali::TouchData const *)arg1)->GetState(arg2);
29941     } catch (std::out_of_range& e) {
29942       {
29943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29944       };
29945     } catch (std::exception& e) {
29946       {
29947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29948       };
29949     } catch (Dali::DaliException e) {
29950       {
29951         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29952       };
29953     } catch (...) {
29954       {
29955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29956       };
29957     }
29958   }
29959
29960   jresult = (int)result;
29961   return jresult;
29962 }
29963
29964
29965 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetHitActor(void * jarg1, unsigned long jarg2) {
29966   void * jresult ;
29967   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29968   std::size_t arg2 ;
29969   Dali::Actor result;
29970
29971   arg1 = (Dali::TouchData *)jarg1;
29972   arg2 = (std::size_t)jarg2;
29973   {
29974     try {
29975       result = ((Dali::TouchData const *)arg1)->GetHitActor(arg2);
29976     } catch (std::out_of_range& e) {
29977       {
29978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29979       };
29980     } catch (std::exception& e) {
29981       {
29982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29983       };
29984     } catch (Dali::DaliException e) {
29985       {
29986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29987       };
29988     } catch (...) {
29989       {
29990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29991       };
29992     }
29993   }
29994
29995   jresult = new Dali::Actor((const Dali::Actor &)result);
29996   return jresult;
29997 }
29998
29999
30000 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetLocalPosition(void * jarg1, unsigned long jarg2) {
30001   void * jresult ;
30002   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30003   std::size_t arg2 ;
30004   Dali::Vector2 *result = 0 ;
30005
30006   arg1 = (Dali::TouchData *)jarg1;
30007   arg2 = (std::size_t)jarg2;
30008   {
30009     try {
30010       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetLocalPosition(arg2);
30011     } catch (std::out_of_range& e) {
30012       {
30013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30014       };
30015     } catch (std::exception& e) {
30016       {
30017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30018       };
30019     } catch (Dali::DaliException e) {
30020       {
30021         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30022       };
30023     } catch (...) {
30024       {
30025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30026       };
30027     }
30028   }
30029
30030   jresult = (void *)result;
30031   return jresult;
30032 }
30033
30034
30035 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetScreenPosition(void * jarg1, unsigned long jarg2) {
30036   void * jresult ;
30037   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30038   std::size_t arg2 ;
30039   Dali::Vector2 *result = 0 ;
30040
30041   arg1 = (Dali::TouchData *)jarg1;
30042   arg2 = (std::size_t)jarg2;
30043   {
30044     try {
30045       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetScreenPosition(arg2);
30046     } catch (std::out_of_range& e) {
30047       {
30048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30049       };
30050     } catch (std::exception& e) {
30051       {
30052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30053       };
30054     } catch (Dali::DaliException e) {
30055       {
30056         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30057       };
30058     } catch (...) {
30059       {
30060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30061       };
30062     }
30063   }
30064
30065   jresult = (void *)result;
30066   return jresult;
30067 }
30068
30069
30070 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetRadius(void * jarg1, unsigned long jarg2) {
30071   float jresult ;
30072   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30073   std::size_t arg2 ;
30074   float result;
30075
30076   arg1 = (Dali::TouchData *)jarg1;
30077   arg2 = (std::size_t)jarg2;
30078   {
30079     try {
30080       result = (float)((Dali::TouchData const *)arg1)->GetRadius(arg2);
30081     } catch (std::out_of_range& e) {
30082       {
30083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30084       };
30085     } catch (std::exception& e) {
30086       {
30087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30088       };
30089     } catch (Dali::DaliException e) {
30090       {
30091         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30092       };
30093     } catch (...) {
30094       {
30095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30096       };
30097     }
30098   }
30099
30100   jresult = result;
30101   return jresult;
30102 }
30103
30104
30105 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetEllipseRadius(void * jarg1, unsigned long jarg2) {
30106   void * jresult ;
30107   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30108   std::size_t arg2 ;
30109   Dali::Vector2 *result = 0 ;
30110
30111   arg1 = (Dali::TouchData *)jarg1;
30112   arg2 = (std::size_t)jarg2;
30113   {
30114     try {
30115       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetEllipseRadius(arg2);
30116     } catch (std::out_of_range& e) {
30117       {
30118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30119       };
30120     } catch (std::exception& e) {
30121       {
30122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30123       };
30124     } catch (Dali::DaliException e) {
30125       {
30126         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30127       };
30128     } catch (...) {
30129       {
30130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30131       };
30132     }
30133   }
30134
30135   jresult = (void *)result;
30136   return jresult;
30137 }
30138
30139
30140 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetPressure(void * jarg1, unsigned long jarg2) {
30141   float jresult ;
30142   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30143   std::size_t arg2 ;
30144   float result;
30145
30146   arg1 = (Dali::TouchData *)jarg1;
30147   arg2 = (std::size_t)jarg2;
30148   {
30149     try {
30150       result = (float)((Dali::TouchData const *)arg1)->GetPressure(arg2);
30151     } catch (std::out_of_range& e) {
30152       {
30153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30154       };
30155     } catch (std::exception& e) {
30156       {
30157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30158       };
30159     } catch (Dali::DaliException e) {
30160       {
30161         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30162       };
30163     } catch (...) {
30164       {
30165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30166       };
30167     }
30168   }
30169
30170   jresult = result;
30171   return jresult;
30172 }
30173
30174
30175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetAngle(void * jarg1, unsigned long jarg2) {
30176   void * jresult ;
30177   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30178   std::size_t arg2 ;
30179   Dali::Degree result;
30180
30181   arg1 = (Dali::TouchData *)jarg1;
30182   arg2 = (std::size_t)jarg2;
30183   {
30184     try {
30185       result = ((Dali::TouchData const *)arg1)->GetAngle(arg2);
30186     } catch (std::out_of_range& e) {
30187       {
30188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30189       };
30190     } catch (std::exception& e) {
30191       {
30192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30193       };
30194     } catch (Dali::DaliException e) {
30195       {
30196         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30197       };
30198     } catch (...) {
30199       {
30200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30201       };
30202     }
30203   }
30204
30205   jresult = new Dali::Degree((const Dali::Degree &)result);
30206   return jresult;
30207 }
30208
30209
30210 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetMouseButton(void * jarg1, unsigned long jarg2) {
30211   int jresult ;
30212   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30213   std::size_t arg2 ;
30214   Dali::MouseButton::Type result;
30215
30216   arg1 = (Dali::TouchData *)jarg1;
30217   arg2 = (std::size_t)jarg2;
30218   {
30219     try {
30220       result = ((Dali::TouchData const *)arg1)->GetMouseButton(arg2);
30221     } catch (std::out_of_range& e) {
30222       {
30223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30224       };
30225     } catch (std::exception& e) {
30226       {
30227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30228       };
30229     } catch (Dali::DaliException e) {
30230       {
30231         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30232       };
30233     } catch (...) {
30234       {
30235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30236       };
30237     }
30238   }
30239
30240   jresult = static_cast< int >(result);
30241   return jresult;
30242 }
30243
30244
30245 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_0() {
30246   void * jresult ;
30247   Dali::GestureDetector *result = 0 ;
30248
30249   {
30250     try {
30251       result = (Dali::GestureDetector *)new Dali::GestureDetector();
30252     } catch (std::out_of_range& e) {
30253       {
30254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30255       };
30256     } catch (std::exception& e) {
30257       {
30258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30259       };
30260     } catch (Dali::DaliException e) {
30261       {
30262         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30263       };
30264     } catch (...) {
30265       {
30266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30267       };
30268     }
30269   }
30270
30271   jresult = (void *)result;
30272   return jresult;
30273 }
30274
30275
30276 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_DownCast(void * jarg1) {
30277   void * jresult ;
30278   Dali::BaseHandle arg1 ;
30279   Dali::BaseHandle *argp1 ;
30280   Dali::GestureDetector result;
30281
30282   argp1 = (Dali::BaseHandle *)jarg1;
30283   if (!argp1) {
30284     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
30285     return 0;
30286   }
30287   arg1 = *argp1;
30288   {
30289     try {
30290       result = Dali::GestureDetector::DownCast(arg1);
30291     } catch (std::out_of_range& e) {
30292       {
30293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30294       };
30295     } catch (std::exception& e) {
30296       {
30297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30298       };
30299     } catch (Dali::DaliException e) {
30300       {
30301         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30302       };
30303     } catch (...) {
30304       {
30305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30306       };
30307     }
30308   }
30309
30310   jresult = new Dali::GestureDetector((const Dali::GestureDetector &)result);
30311   return jresult;
30312 }
30313
30314
30315 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GestureDetector(void * jarg1) {
30316   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30317
30318   arg1 = (Dali::GestureDetector *)jarg1;
30319   {
30320     try {
30321       delete arg1;
30322     } catch (std::out_of_range& e) {
30323       {
30324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30325       };
30326     } catch (std::exception& e) {
30327       {
30328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30329       };
30330     } catch (Dali::DaliException e) {
30331       {
30332         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30333       };
30334     } catch (...) {
30335       {
30336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30337       };
30338     }
30339   }
30340
30341 }
30342
30343
30344 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_1(void * jarg1) {
30345   void * jresult ;
30346   Dali::GestureDetector *arg1 = 0 ;
30347   Dali::GestureDetector *result = 0 ;
30348
30349   arg1 = (Dali::GestureDetector *)jarg1;
30350   if (!arg1) {
30351     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
30352     return 0;
30353   }
30354   {
30355     try {
30356       result = (Dali::GestureDetector *)new Dali::GestureDetector((Dali::GestureDetector const &)*arg1);
30357     } catch (std::out_of_range& e) {
30358       {
30359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30360       };
30361     } catch (std::exception& e) {
30362       {
30363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30364       };
30365     } catch (Dali::DaliException e) {
30366       {
30367         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30368       };
30369     } catch (...) {
30370       {
30371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30372       };
30373     }
30374   }
30375
30376   jresult = (void *)result;
30377   return jresult;
30378 }
30379
30380
30381 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_Assign(void * jarg1, void * jarg2) {
30382   void * jresult ;
30383   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30384   Dali::GestureDetector *arg2 = 0 ;
30385   Dali::GestureDetector *result = 0 ;
30386
30387   arg1 = (Dali::GestureDetector *)jarg1;
30388   arg2 = (Dali::GestureDetector *)jarg2;
30389   if (!arg2) {
30390     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
30391     return 0;
30392   }
30393   {
30394     try {
30395       result = (Dali::GestureDetector *) &(arg1)->operator =((Dali::GestureDetector const &)*arg2);
30396     } catch (std::out_of_range& e) {
30397       {
30398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30399       };
30400     } catch (std::exception& e) {
30401       {
30402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30403       };
30404     } catch (Dali::DaliException e) {
30405       {
30406         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30407       };
30408     } catch (...) {
30409       {
30410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30411       };
30412     }
30413   }
30414
30415   jresult = (void *)result;
30416   return jresult;
30417 }
30418
30419
30420 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Attach(void * jarg1, void * jarg2) {
30421   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30422   Dali::Actor arg2 ;
30423   Dali::Actor *argp2 ;
30424
30425   arg1 = (Dali::GestureDetector *)jarg1;
30426   argp2 = (Dali::Actor *)jarg2;
30427   if (!argp2) {
30428     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
30429     return ;
30430   }
30431   arg2 = *argp2;
30432   {
30433     try {
30434       (arg1)->Attach(arg2);
30435     } catch (std::out_of_range& e) {
30436       {
30437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30438       };
30439     } catch (std::exception& e) {
30440       {
30441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30442       };
30443     } catch (Dali::DaliException e) {
30444       {
30445         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30446       };
30447     } catch (...) {
30448       {
30449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30450       };
30451     }
30452   }
30453
30454 }
30455
30456
30457 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Detach(void * jarg1, void * jarg2) {
30458   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30459   Dali::Actor arg2 ;
30460   Dali::Actor *argp2 ;
30461
30462   arg1 = (Dali::GestureDetector *)jarg1;
30463   argp2 = (Dali::Actor *)jarg2;
30464   if (!argp2) {
30465     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
30466     return ;
30467   }
30468   arg2 = *argp2;
30469   {
30470     try {
30471       (arg1)->Detach(arg2);
30472     } catch (std::out_of_range& e) {
30473       {
30474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30475       };
30476     } catch (std::exception& e) {
30477       {
30478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30479       };
30480     } catch (Dali::DaliException e) {
30481       {
30482         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30483       };
30484     } catch (...) {
30485       {
30486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30487       };
30488     }
30489   }
30490
30491 }
30492
30493
30494 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_DetachAll(void * jarg1) {
30495   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30496
30497   arg1 = (Dali::GestureDetector *)jarg1;
30498   {
30499     try {
30500       (arg1)->DetachAll();
30501     } catch (std::out_of_range& e) {
30502       {
30503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30504       };
30505     } catch (std::exception& e) {
30506       {
30507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30508       };
30509     } catch (Dali::DaliException e) {
30510       {
30511         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30512       };
30513     } catch (...) {
30514       {
30515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30516       };
30517     }
30518   }
30519
30520 }
30521
30522
30523 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActorCount(void * jarg1) {
30524   unsigned long jresult ;
30525   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30526   size_t result;
30527
30528   arg1 = (Dali::GestureDetector *)jarg1;
30529   {
30530     try {
30531       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActorCount();
30532     } catch (std::out_of_range& e) {
30533       {
30534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30535       };
30536     } catch (std::exception& e) {
30537       {
30538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30539       };
30540     } catch (Dali::DaliException e) {
30541       {
30542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30543       };
30544     } catch (...) {
30545       {
30546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30547       };
30548     }
30549   }
30550
30551   jresult = (unsigned long)result;
30552   return jresult;
30553 }
30554
30555
30556 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActor(void * jarg1, unsigned long jarg2) {
30557   void * jresult ;
30558   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30559   size_t arg2 ;
30560   Dali::Actor result;
30561
30562   arg1 = (Dali::GestureDetector *)jarg1;
30563   arg2 = (size_t)jarg2;
30564   {
30565     try {
30566       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActor(arg2);
30567     } catch (std::out_of_range& e) {
30568       {
30569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30570       };
30571     } catch (std::exception& e) {
30572       {
30573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30574       };
30575     } catch (Dali::DaliException e) {
30576       {
30577         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30578       };
30579     } catch (...) {
30580       {
30581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30582       };
30583     }
30584   }
30585
30586   jresult = new Dali::Actor((const Dali::Actor &)result);
30587   return jresult;
30588 }
30589
30590
30591 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Gesture(void * jarg1) {
30592   void * jresult ;
30593   Dali::Gesture *arg1 = 0 ;
30594   Dali::Gesture *result = 0 ;
30595
30596   arg1 = (Dali::Gesture *)jarg1;
30597   if (!arg1) {
30598     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
30599     return 0;
30600   }
30601   {
30602     try {
30603       result = (Dali::Gesture *)new Dali::Gesture((Dali::Gesture const &)*arg1);
30604     } catch (std::out_of_range& e) {
30605       {
30606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30607       };
30608     } catch (std::exception& e) {
30609       {
30610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30611       };
30612     } catch (Dali::DaliException e) {
30613       {
30614         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30615       };
30616     } catch (...) {
30617       {
30618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30619       };
30620     }
30621   }
30622
30623   jresult = (void *)result;
30624   return jresult;
30625 }
30626
30627
30628 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Gesture_Assign(void * jarg1, void * jarg2) {
30629   void * jresult ;
30630   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30631   Dali::Gesture *arg2 = 0 ;
30632   Dali::Gesture *result = 0 ;
30633
30634   arg1 = (Dali::Gesture *)jarg1;
30635   arg2 = (Dali::Gesture *)jarg2;
30636   if (!arg2) {
30637     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
30638     return 0;
30639   }
30640   {
30641     try {
30642       result = (Dali::Gesture *) &(arg1)->operator =((Dali::Gesture const &)*arg2);
30643     } catch (std::out_of_range& e) {
30644       {
30645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30646       };
30647     } catch (std::exception& e) {
30648       {
30649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30650       };
30651     } catch (Dali::DaliException e) {
30652       {
30653         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30654       };
30655     } catch (...) {
30656       {
30657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30658       };
30659     }
30660   }
30661
30662   jresult = (void *)result;
30663   return jresult;
30664 }
30665
30666
30667 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Gesture(void * jarg1) {
30668   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30669
30670   arg1 = (Dali::Gesture *)jarg1;
30671   {
30672     try {
30673       delete arg1;
30674     } catch (std::out_of_range& e) {
30675       {
30676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30677       };
30678     } catch (std::exception& e) {
30679       {
30680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30681       };
30682     } catch (Dali::DaliException e) {
30683       {
30684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30685       };
30686     } catch (...) {
30687       {
30688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30689       };
30690     }
30691   }
30692
30693 }
30694
30695
30696 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_type_set(void * jarg1, int jarg2) {
30697   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30698   Dali::Gesture::Type arg2 ;
30699
30700   arg1 = (Dali::Gesture *)jarg1;
30701   arg2 = (Dali::Gesture::Type)jarg2;
30702   if (arg1) (arg1)->type = arg2;
30703 }
30704
30705
30706 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_type_get(void * jarg1) {
30707   int jresult ;
30708   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30709   Dali::Gesture::Type result;
30710
30711   arg1 = (Dali::Gesture *)jarg1;
30712   result = (Dali::Gesture::Type) ((arg1)->type);
30713   jresult = (int)result;
30714   return jresult;
30715 }
30716
30717
30718 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_state_set(void * jarg1, int jarg2) {
30719   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30720   Dali::Gesture::State arg2 ;
30721
30722   arg1 = (Dali::Gesture *)jarg1;
30723   arg2 = (Dali::Gesture::State)jarg2;
30724   if (arg1) (arg1)->state = arg2;
30725 }
30726
30727
30728 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_state_get(void * jarg1) {
30729   int jresult ;
30730   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30731   Dali::Gesture::State result;
30732
30733   arg1 = (Dali::Gesture *)jarg1;
30734   result = (Dali::Gesture::State) ((arg1)->state);
30735   jresult = (int)result;
30736   return jresult;
30737 }
30738
30739
30740 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_time_set(void * jarg1, unsigned int jarg2) {
30741   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30742   unsigned int arg2 ;
30743
30744   arg1 = (Dali::Gesture *)jarg1;
30745   arg2 = (unsigned int)jarg2;
30746   if (arg1) (arg1)->time = arg2;
30747 }
30748
30749
30750 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Gesture_time_get(void * jarg1) {
30751   unsigned int jresult ;
30752   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30753   unsigned int result;
30754
30755   arg1 = (Dali::Gesture *)jarg1;
30756   result = (unsigned int) ((arg1)->time);
30757   jresult = result;
30758   return jresult;
30759 }
30760
30761
30762 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_0() {
30763   void * jresult ;
30764   Dali::HoverEvent *result = 0 ;
30765
30766   {
30767     try {
30768       result = (Dali::HoverEvent *)new Dali::HoverEvent();
30769     } catch (std::out_of_range& e) {
30770       {
30771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30772       };
30773     } catch (std::exception& e) {
30774       {
30775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30776       };
30777     } catch (Dali::DaliException e) {
30778       {
30779         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30780       };
30781     } catch (...) {
30782       {
30783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30784       };
30785     }
30786   }
30787
30788   jresult = (void *)result;
30789   return jresult;
30790 }
30791
30792
30793 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_1(unsigned long jarg1) {
30794   void * jresult ;
30795   unsigned long arg1 ;
30796   Dali::HoverEvent *result = 0 ;
30797
30798   arg1 = (unsigned long)jarg1;
30799   {
30800     try {
30801       result = (Dali::HoverEvent *)new Dali::HoverEvent(arg1);
30802     } catch (std::out_of_range& e) {
30803       {
30804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30805       };
30806     } catch (std::exception& e) {
30807       {
30808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30809       };
30810     } catch (Dali::DaliException e) {
30811       {
30812         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30813       };
30814     } catch (...) {
30815       {
30816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30817       };
30818     }
30819   }
30820
30821   jresult = (void *)result;
30822   return jresult;
30823 }
30824
30825
30826 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Hover(void * jarg1) {
30827   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30828
30829   arg1 = (Dali::HoverEvent *)jarg1;
30830   {
30831     try {
30832       delete arg1;
30833     } catch (std::out_of_range& e) {
30834       {
30835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30836       };
30837     } catch (std::exception& e) {
30838       {
30839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30840       };
30841     } catch (Dali::DaliException e) {
30842       {
30843         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30844       };
30845     } catch (...) {
30846       {
30847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30848       };
30849     }
30850   }
30851
30852 }
30853
30854
30855 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Hover_points_set(void * jarg1, void * jarg2) {
30856   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30857   Dali::TouchPointContainer *arg2 = (Dali::TouchPointContainer *) 0 ;
30858
30859   arg1 = (Dali::HoverEvent *)jarg1;
30860   arg2 = (Dali::TouchPointContainer *)jarg2;
30861   if (arg1) (arg1)->points = *arg2;
30862 }
30863
30864
30865 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_points_get(void * jarg1) {
30866   void * jresult ;
30867   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30868   Dali::TouchPointContainer *result = 0 ;
30869
30870   arg1 = (Dali::HoverEvent *)jarg1;
30871   result = (Dali::TouchPointContainer *)& ((arg1)->points);
30872   jresult = (void *)result;
30873   return jresult;
30874 }
30875
30876
30877 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Hover_time_set(void * jarg1, unsigned long jarg2) {
30878   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30879   unsigned long arg2 ;
30880
30881   arg1 = (Dali::HoverEvent *)jarg1;
30882   arg2 = (unsigned long)jarg2;
30883   if (arg1) (arg1)->time = arg2;
30884 }
30885
30886
30887 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Hover_time_get(void * jarg1) {
30888   unsigned long jresult ;
30889   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30890   unsigned long result;
30891
30892   arg1 = (Dali::HoverEvent *)jarg1;
30893   result = (unsigned long) ((arg1)->time);
30894   jresult = (unsigned long)result;
30895   return jresult;
30896 }
30897
30898
30899 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Hover_GetPointCount(void * jarg1) {
30900   unsigned int jresult ;
30901   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30902   unsigned int result;
30903
30904   arg1 = (Dali::HoverEvent *)jarg1;
30905   {
30906     try {
30907       result = (unsigned int)((Dali::HoverEvent const *)arg1)->GetPointCount();
30908     } catch (std::out_of_range& e) {
30909       {
30910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30911       };
30912     } catch (std::exception& e) {
30913       {
30914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30915       };
30916     } catch (Dali::DaliException e) {
30917       {
30918         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30919       };
30920     } catch (...) {
30921       {
30922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30923       };
30924     }
30925   }
30926
30927   jresult = result;
30928   return jresult;
30929 }
30930
30931
30932 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_GetPoint(void * jarg1, unsigned int jarg2) {
30933   void * jresult ;
30934   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30935   unsigned int arg2 ;
30936   Dali::TouchPoint *result = 0 ;
30937
30938   arg1 = (Dali::HoverEvent *)jarg1;
30939   arg2 = (unsigned int)jarg2;
30940   {
30941     try {
30942       result = (Dali::TouchPoint *) &((Dali::HoverEvent const *)arg1)->GetPoint(arg2);
30943     } catch (std::out_of_range& e) {
30944       {
30945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30946       };
30947     } catch (std::exception& e) {
30948       {
30949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30950       };
30951     } catch (Dali::DaliException e) {
30952       {
30953         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30954       };
30955     } catch (...) {
30956       {
30957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30958       };
30959     }
30960   }
30961
30962   jresult = (void *)result;
30963   return jresult;
30964 }
30965
30966
30967 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_0() {
30968   void * jresult ;
30969   Dali::KeyEvent *result = 0 ;
30970
30971   {
30972     try {
30973       result = (Dali::KeyEvent *)new Dali::KeyEvent();
30974     } catch (std::out_of_range& e) {
30975       {
30976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30977       };
30978     } catch (std::exception& e) {
30979       {
30980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30981       };
30982     } catch (Dali::DaliException e) {
30983       {
30984         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30985       };
30986     } catch (...) {
30987       {
30988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30989       };
30990     }
30991   }
30992
30993   jresult = (void *)result;
30994   return jresult;
30995 }
30996
30997
30998 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_1(char * jarg1, char * jarg2, int jarg3, int jarg4, unsigned long jarg5, int jarg6) {
30999   void * jresult ;
31000   std::string *arg1 = 0 ;
31001   std::string *arg2 = 0 ;
31002   int arg3 ;
31003   int arg4 ;
31004   unsigned long arg5 ;
31005   Dali::KeyEvent::State *arg6 = 0 ;
31006   Dali::KeyEvent::State temp6 ;
31007   Dali::KeyEvent *result = 0 ;
31008
31009   if (!jarg1) {
31010     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31011     return 0;
31012   }
31013   std::string arg1_str(jarg1);
31014   arg1 = &arg1_str;
31015   if (!jarg2) {
31016     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31017     return 0;
31018   }
31019   std::string arg2_str(jarg2);
31020   arg2 = &arg2_str;
31021   arg3 = (int)jarg3;
31022   arg4 = (int)jarg4;
31023   arg5 = (unsigned long)jarg5;
31024   temp6 = (Dali::KeyEvent::State)jarg6;
31025   arg6 = &temp6;
31026   {
31027     try {
31028       result = (Dali::KeyEvent *)new Dali::KeyEvent((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,(Dali::KeyEvent::State const &)*arg6);
31029     } catch (std::out_of_range& e) {
31030       {
31031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31032       };
31033     } catch (std::exception& e) {
31034       {
31035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31036       };
31037     } catch (Dali::DaliException e) {
31038       {
31039         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31040       };
31041     } catch (...) {
31042       {
31043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31044       };
31045     }
31046   }
31047
31048   jresult = (void *)result;
31049
31050   //argout typemap for const std::string&
31051
31052
31053   //argout typemap for const std::string&
31054
31055   return jresult;
31056 }
31057
31058 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_2(void * jarg1) {
31059   void * jresult ;
31060   Dali::KeyEvent *arg1 = 0 ;
31061   Dali::KeyEvent *result = 0 ;
31062
31063   arg1 = (Dali::KeyEvent *)jarg1;
31064   if (!arg1) {
31065     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
31066     return 0;
31067   }
31068   {
31069     try {
31070       result = (Dali::KeyEvent *)new Dali::KeyEvent((Dali::KeyEvent const &)*arg1);
31071     } catch (std::out_of_range& e) {
31072       {
31073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31074       };
31075     } catch (std::exception& e) {
31076       {
31077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31078       };
31079     } catch (Dali::DaliException e) {
31080       {
31081         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31082       };
31083     } catch (...) {
31084       {
31085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31086       };
31087     }
31088   }
31089
31090   jresult = (void *)result;
31091   return jresult;
31092 }
31093
31094
31095 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Key_Assign(void * jarg1, void * jarg2) {
31096   void * jresult ;
31097   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31098   Dali::KeyEvent *arg2 = 0 ;
31099   Dali::KeyEvent *result = 0 ;
31100
31101   arg1 = (Dali::KeyEvent *)jarg1;
31102   arg2 = (Dali::KeyEvent *)jarg2;
31103   if (!arg2) {
31104     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
31105     return 0;
31106   }
31107   {
31108     try {
31109       result = (Dali::KeyEvent *) &(arg1)->operator =((Dali::KeyEvent const &)*arg2);
31110     } catch (std::out_of_range& e) {
31111       {
31112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31113       };
31114     } catch (std::exception& e) {
31115       {
31116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31117       };
31118     } catch (Dali::DaliException e) {
31119       {
31120         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31121       };
31122     } catch (...) {
31123       {
31124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31125       };
31126     }
31127   }
31128
31129   jresult = (void *)result;
31130   return jresult;
31131 }
31132
31133
31134 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Key(void * jarg1) {
31135   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31136
31137   arg1 = (Dali::KeyEvent *)jarg1;
31138   {
31139     try {
31140       delete arg1;
31141     } catch (std::out_of_range& e) {
31142       {
31143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31144       };
31145     } catch (std::exception& e) {
31146       {
31147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31148       };
31149     } catch (Dali::DaliException e) {
31150       {
31151         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31152       };
31153     } catch (...) {
31154       {
31155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31156       };
31157     }
31158   }
31159
31160 }
31161
31162
31163 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsShiftModifier(void * jarg1) {
31164   unsigned int jresult ;
31165   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31166   bool result;
31167
31168   arg1 = (Dali::KeyEvent *)jarg1;
31169   {
31170     try {
31171       result = (bool)((Dali::KeyEvent const *)arg1)->IsShiftModifier();
31172     } catch (std::out_of_range& e) {
31173       {
31174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31175       };
31176     } catch (std::exception& e) {
31177       {
31178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31179       };
31180     } catch (Dali::DaliException e) {
31181       {
31182         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31183       };
31184     } catch (...) {
31185       {
31186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31187       };
31188     }
31189   }
31190
31191   jresult = result;
31192   return jresult;
31193 }
31194
31195
31196 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsCtrlModifier(void * jarg1) {
31197   unsigned int jresult ;
31198   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31199   bool result;
31200
31201   arg1 = (Dali::KeyEvent *)jarg1;
31202   {
31203     try {
31204       result = (bool)((Dali::KeyEvent const *)arg1)->IsCtrlModifier();
31205     } catch (std::out_of_range& e) {
31206       {
31207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31208       };
31209     } catch (std::exception& e) {
31210       {
31211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31212       };
31213     } catch (Dali::DaliException e) {
31214       {
31215         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31216       };
31217     } catch (...) {
31218       {
31219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31220       };
31221     }
31222   }
31223
31224   jresult = result;
31225   return jresult;
31226 }
31227
31228
31229 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsAltModifier(void * jarg1) {
31230   unsigned int jresult ;
31231   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31232   bool result;
31233
31234   arg1 = (Dali::KeyEvent *)jarg1;
31235   {
31236     try {
31237       result = (bool)((Dali::KeyEvent const *)arg1)->IsAltModifier();
31238     } catch (std::out_of_range& e) {
31239       {
31240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31241       };
31242     } catch (std::exception& e) {
31243       {
31244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31245       };
31246     } catch (Dali::DaliException e) {
31247       {
31248         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31249       };
31250     } catch (...) {
31251       {
31252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31253       };
31254     }
31255   }
31256
31257   jresult = result;
31258   return jresult;
31259 }
31260
31261
31262 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressedName_set(void * jarg1, char * jarg2) {
31263   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31264   std::string *arg2 = 0 ;
31265
31266   arg1 = (Dali::KeyEvent *)jarg1;
31267   if (!jarg2) {
31268     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31269     return ;
31270   }
31271   std::string arg2_str(jarg2);
31272   arg2 = &arg2_str;
31273   if (arg1) (arg1)->keyPressedName = *arg2;
31274
31275   //argout typemap for const std::string&
31276
31277 }
31278
31279
31280 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressedName_get(void * jarg1) {
31281   char * jresult ;
31282
31283   if( jarg1 == NULL )
31284   {
31285     jresult = SWIG_csharp_string_callback( "" );
31286   }
31287   else
31288   {
31289     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31290     std::string *result = 0;
31291
31292     arg1 = ( Dali::KeyEvent * )jarg1;
31293     result = ( std::string * ) & ( ( arg1 )->keyPressedName );
31294     jresult = SWIG_csharp_string_callback( result->c_str() );
31295   }
31296
31297   return jresult;
31298 }
31299
31300
31301 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressed_set(void * jarg1, char * jarg2) {
31302   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31303   std::string *arg2 = 0 ;
31304
31305   arg1 = (Dali::KeyEvent *)jarg1;
31306   if (!jarg2) {
31307     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31308     return ;
31309   }
31310   std::string arg2_str(jarg2);
31311   arg2 = &arg2_str;
31312   if (arg1) (arg1)->keyPressed = *arg2;
31313
31314   //argout typemap for const std::string&
31315
31316 }
31317
31318
31319 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressed_get(void * jarg1) {
31320   char * jresult ;
31321   if( NULL == jarg1 )
31322   {
31323     jresult = SWIG_csharp_string_callback( "" );
31324   }
31325   else
31326   {
31327     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31328     std::string *result = 0;
31329
31330     arg1 = ( Dali::KeyEvent * )jarg1;
31331     result = ( std::string * ) & ( ( arg1 )->keyPressed );
31332     jresult = SWIG_csharp_string_callback( result->c_str() );
31333   }
31334   return jresult;
31335 }
31336
31337
31338 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyCode_set(void * jarg1, int jarg2) {
31339   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31340   int arg2 ;
31341
31342   arg1 = (Dali::KeyEvent *)jarg1;
31343   arg2 = (int)jarg2;
31344   if (arg1) (arg1)->keyCode = arg2;
31345 }
31346
31347
31348 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyCode_get(void * jarg1) {
31349   int jresult ;
31350   if( NULL == jarg1 )
31351   {
31352     jresult = -1;
31353   }
31354   else
31355   {
31356     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31357     int result;
31358
31359     arg1 = ( Dali::KeyEvent * )jarg1;
31360     result = (int)( ( arg1 )->keyCode );
31361     jresult = result;
31362   }
31363   return jresult;
31364 }
31365
31366
31367 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyModifier_set(void * jarg1, int jarg2) {
31368   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31369   int arg2 ;
31370
31371   arg1 = (Dali::KeyEvent *)jarg1;
31372   arg2 = (int)jarg2;
31373   if (arg1) (arg1)->keyModifier = arg2;
31374 }
31375
31376
31377 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyModifier_get(void * jarg1) {
31378   int jresult ;
31379   if( jarg1 == NULL )
31380   {
31381     jresult = -1;
31382   }
31383   else
31384   {
31385     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31386     int result;
31387
31388     arg1 = ( Dali::KeyEvent * )jarg1;
31389     result = (int)( ( arg1 )->keyModifier );
31390     jresult = result;
31391   }
31392   return jresult;
31393 }
31394
31395
31396 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_time_set(void * jarg1, unsigned long jarg2) {
31397   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31398   unsigned long arg2 ;
31399
31400   arg1 = (Dali::KeyEvent *)jarg1;
31401   arg2 = (unsigned long)jarg2;
31402   if (arg1) (arg1)->time = arg2;
31403 }
31404
31405
31406 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Key_time_get(void * jarg1) {
31407   unsigned long jresult ;
31408   if( jarg1 == NULL )
31409   {
31410     jresult = 0;
31411   }
31412   else
31413   {
31414     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31415     unsigned long result;
31416
31417     arg1 = ( Dali::KeyEvent * )jarg1;
31418     result = (unsigned long)( ( arg1 )->time );
31419     jresult = (unsigned long)result;
31420   }
31421   return jresult;
31422 }
31423
31424
31425 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_state_set(void * jarg1, int jarg2) {
31426   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31427   Dali::KeyEvent::State arg2 ;
31428
31429   arg1 = (Dali::KeyEvent *)jarg1;
31430   arg2 = (Dali::KeyEvent::State)jarg2;
31431   if (arg1) (arg1)->state = arg2;
31432 }
31433
31434
31435 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_state_get(void * jarg1) {
31436   int jresult ;
31437   if( jarg1 == NULL )
31438   {
31439     jresult = -1;
31440   }
31441   else
31442   {
31443     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31444     Dali::KeyEvent::State result;
31445
31446     arg1 = ( Dali::KeyEvent * )jarg1;
31447     result = ( Dali::KeyEvent::State ) ( ( arg1 )->state );
31448     jresult = (int)result;
31449   }
31450   return jresult;
31451 }
31452
31453
31454 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_0() {
31455   void * jresult ;
31456   Dali::LongPressGestureDetector *result = 0 ;
31457
31458   {
31459     try {
31460       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector();
31461     } catch (std::out_of_range& e) {
31462       {
31463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31464       };
31465     } catch (std::exception& e) {
31466       {
31467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31468       };
31469     } catch (Dali::DaliException e) {
31470       {
31471         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31472       };
31473     } catch (...) {
31474       {
31475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31476       };
31477     }
31478   }
31479
31480   jresult = (void *)result;
31481   return jresult;
31482 }
31483
31484
31485 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_0() {
31486   void * jresult ;
31487   Dali::LongPressGestureDetector result;
31488
31489   {
31490     try {
31491       result = Dali::LongPressGestureDetector::New();
31492     } catch (std::out_of_range& e) {
31493       {
31494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31495       };
31496     } catch (std::exception& e) {
31497       {
31498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31499       };
31500     } catch (Dali::DaliException e) {
31501       {
31502         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31503       };
31504     } catch (...) {
31505       {
31506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31507       };
31508     }
31509   }
31510
31511   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31512   return jresult;
31513 }
31514
31515
31516 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_1(unsigned int jarg1) {
31517   void * jresult ;
31518   unsigned int arg1 ;
31519   Dali::LongPressGestureDetector result;
31520
31521   arg1 = (unsigned int)jarg1;
31522   {
31523     try {
31524       result = Dali::LongPressGestureDetector::New(arg1);
31525     } catch (std::out_of_range& e) {
31526       {
31527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31528       };
31529     } catch (std::exception& e) {
31530       {
31531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31532       };
31533     } catch (Dali::DaliException e) {
31534       {
31535         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31536       };
31537     } catch (...) {
31538       {
31539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31540       };
31541     }
31542   }
31543
31544   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31545   return jresult;
31546 }
31547
31548
31549 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
31550   void * jresult ;
31551   unsigned int arg1 ;
31552   unsigned int arg2 ;
31553   Dali::LongPressGestureDetector result;
31554
31555   arg1 = (unsigned int)jarg1;
31556   arg2 = (unsigned int)jarg2;
31557   {
31558     try {
31559       result = Dali::LongPressGestureDetector::New(arg1,arg2);
31560     } catch (std::out_of_range& e) {
31561       {
31562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31563       };
31564     } catch (std::exception& e) {
31565       {
31566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31567       };
31568     } catch (Dali::DaliException e) {
31569       {
31570         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31571       };
31572     } catch (...) {
31573       {
31574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31575       };
31576     }
31577   }
31578
31579   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31580   return jresult;
31581 }
31582
31583
31584 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DownCast(void * jarg1) {
31585   void * jresult ;
31586   Dali::BaseHandle arg1 ;
31587   Dali::BaseHandle *argp1 ;
31588   Dali::LongPressGestureDetector result;
31589
31590   argp1 = (Dali::BaseHandle *)jarg1;
31591   if (!argp1) {
31592     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
31593     return 0;
31594   }
31595   arg1 = *argp1;
31596   {
31597     try {
31598       result = Dali::LongPressGestureDetector::DownCast(arg1);
31599     } catch (std::out_of_range& e) {
31600       {
31601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31602       };
31603     } catch (std::exception& e) {
31604       {
31605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31606       };
31607     } catch (Dali::DaliException e) {
31608       {
31609         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31610       };
31611     } catch (...) {
31612       {
31613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31614       };
31615     }
31616   }
31617
31618   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31619   return jresult;
31620 }
31621
31622
31623 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetector(void * jarg1) {
31624   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31625
31626   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31627   {
31628     try {
31629       delete arg1;
31630     } catch (std::out_of_range& e) {
31631       {
31632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31633       };
31634     } catch (std::exception& e) {
31635       {
31636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31637       };
31638     } catch (Dali::DaliException e) {
31639       {
31640         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31641       };
31642     } catch (...) {
31643       {
31644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31645       };
31646     }
31647   }
31648
31649 }
31650
31651
31652 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_1(void * jarg1) {
31653   void * jresult ;
31654   Dali::LongPressGestureDetector *arg1 = 0 ;
31655   Dali::LongPressGestureDetector *result = 0 ;
31656
31657   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31658   if (!arg1) {
31659     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
31660     return 0;
31661   }
31662   {
31663     try {
31664       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector((Dali::LongPressGestureDetector const &)*arg1);
31665     } catch (std::out_of_range& e) {
31666       {
31667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31668       };
31669     } catch (std::exception& e) {
31670       {
31671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31672       };
31673     } catch (Dali::DaliException e) {
31674       {
31675         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31676       };
31677     } catch (...) {
31678       {
31679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31680       };
31681     }
31682   }
31683
31684   jresult = (void *)result;
31685   return jresult;
31686 }
31687
31688
31689 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_Assign(void * jarg1, void * jarg2) {
31690   void * jresult ;
31691   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31692   Dali::LongPressGestureDetector *arg2 = 0 ;
31693   Dali::LongPressGestureDetector *result = 0 ;
31694
31695   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31696   arg2 = (Dali::LongPressGestureDetector *)jarg2;
31697   if (!arg2) {
31698     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
31699     return 0;
31700   }
31701   {
31702     try {
31703       result = (Dali::LongPressGestureDetector *) &(arg1)->operator =((Dali::LongPressGestureDetector const &)*arg2);
31704     } catch (std::out_of_range& e) {
31705       {
31706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31707       };
31708     } catch (std::exception& e) {
31709       {
31710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31711       };
31712     } catch (Dali::DaliException e) {
31713       {
31714         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31715       };
31716     } catch (...) {
31717       {
31718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31719       };
31720     }
31721   }
31722
31723   jresult = (void *)result;
31724   return jresult;
31725 }
31726
31727
31728 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_0(void * jarg1, unsigned int jarg2) {
31729   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31730   unsigned int arg2 ;
31731
31732   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31733   arg2 = (unsigned int)jarg2;
31734   {
31735     try {
31736       (arg1)->SetTouchesRequired(arg2);
31737     } catch (std::out_of_range& e) {
31738       {
31739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31740       };
31741     } catch (std::exception& e) {
31742       {
31743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31744       };
31745     } catch (Dali::DaliException e) {
31746       {
31747         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31748       };
31749     } catch (...) {
31750       {
31751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31752       };
31753     }
31754   }
31755
31756 }
31757
31758
31759 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
31760   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31761   unsigned int arg2 ;
31762   unsigned int arg3 ;
31763
31764   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31765   arg2 = (unsigned int)jarg2;
31766   arg3 = (unsigned int)jarg3;
31767   {
31768     try {
31769       (arg1)->SetTouchesRequired(arg2,arg3);
31770     } catch (std::out_of_range& e) {
31771       {
31772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31773       };
31774     } catch (std::exception& e) {
31775       {
31776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31777       };
31778     } catch (Dali::DaliException e) {
31779       {
31780         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31781       };
31782     } catch (...) {
31783       {
31784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31785       };
31786     }
31787   }
31788
31789 }
31790
31791
31792 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
31793   unsigned int jresult ;
31794   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31795   unsigned int result;
31796
31797   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31798   {
31799     try {
31800       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMinimumTouchesRequired();
31801     } catch (std::out_of_range& e) {
31802       {
31803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31804       };
31805     } catch (std::exception& e) {
31806       {
31807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31808       };
31809     } catch (Dali::DaliException e) {
31810       {
31811         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31812       };
31813     } catch (...) {
31814       {
31815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31816       };
31817     }
31818   }
31819
31820   jresult = result;
31821   return jresult;
31822 }
31823
31824
31825 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
31826   unsigned int jresult ;
31827   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31828   unsigned int result;
31829
31830   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31831   {
31832     try {
31833       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMaximumTouchesRequired();
31834     } catch (std::out_of_range& e) {
31835       {
31836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31837       };
31838     } catch (std::exception& e) {
31839       {
31840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31841       };
31842     } catch (Dali::DaliException e) {
31843       {
31844         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31845       };
31846     } catch (...) {
31847       {
31848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31849       };
31850     }
31851   }
31852
31853   jresult = result;
31854   return jresult;
31855 }
31856
31857
31858 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DetectedSignal(void * jarg1) {
31859   void * jresult ;
31860   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31861   Dali::LongPressGestureDetector::DetectedSignalType *result = 0 ;
31862
31863   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31864   {
31865     try {
31866       result = (Dali::LongPressGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
31867     } catch (std::out_of_range& e) {
31868       {
31869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31870       };
31871     } catch (std::exception& e) {
31872       {
31873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31874       };
31875     } catch (Dali::DaliException e) {
31876       {
31877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31878       };
31879     } catch (...) {
31880       {
31881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31882       };
31883     }
31884   }
31885
31886   jresult = (void *)result;
31887   return jresult;
31888 }
31889
31890
31891 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_0(int jarg1) {
31892   void * jresult ;
31893   Dali::Gesture::State arg1 ;
31894   Dali::LongPressGesture *result = 0 ;
31895
31896   arg1 = (Dali::Gesture::State)jarg1;
31897   {
31898     try {
31899       result = (Dali::LongPressGesture *)new Dali::LongPressGesture(arg1);
31900     } catch (std::out_of_range& e) {
31901       {
31902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31903       };
31904     } catch (std::exception& e) {
31905       {
31906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31907       };
31908     } catch (Dali::DaliException e) {
31909       {
31910         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31911       };
31912     } catch (...) {
31913       {
31914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31915       };
31916     }
31917   }
31918
31919   jresult = (void *)result;
31920   return jresult;
31921 }
31922
31923
31924 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_1(void * jarg1) {
31925   void * jresult ;
31926   Dali::LongPressGesture *arg1 = 0 ;
31927   Dali::LongPressGesture *result = 0 ;
31928
31929   arg1 = (Dali::LongPressGesture *)jarg1;
31930   if (!arg1) {
31931     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
31932     return 0;
31933   }
31934   {
31935     try {
31936       result = (Dali::LongPressGesture *)new Dali::LongPressGesture((Dali::LongPressGesture const &)*arg1);
31937     } catch (std::out_of_range& e) {
31938       {
31939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31940       };
31941     } catch (std::exception& e) {
31942       {
31943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31944       };
31945     } catch (Dali::DaliException e) {
31946       {
31947         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31948       };
31949     } catch (...) {
31950       {
31951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31952       };
31953     }
31954   }
31955
31956   jresult = (void *)result;
31957   return jresult;
31958 }
31959
31960
31961 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_Assign(void * jarg1, void * jarg2) {
31962   void * jresult ;
31963   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
31964   Dali::LongPressGesture *arg2 = 0 ;
31965   Dali::LongPressGesture *result = 0 ;
31966
31967   arg1 = (Dali::LongPressGesture *)jarg1;
31968   arg2 = (Dali::LongPressGesture *)jarg2;
31969   if (!arg2) {
31970     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
31971     return 0;
31972   }
31973   {
31974     try {
31975       result = (Dali::LongPressGesture *) &(arg1)->operator =((Dali::LongPressGesture const &)*arg2);
31976     } catch (std::out_of_range& e) {
31977       {
31978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31979       };
31980     } catch (std::exception& e) {
31981       {
31982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31983       };
31984     } catch (Dali::DaliException e) {
31985       {
31986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31987       };
31988     } catch (...) {
31989       {
31990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31991       };
31992     }
31993   }
31994
31995   jresult = (void *)result;
31996   return jresult;
31997 }
31998
31999
32000 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGesture(void * jarg1) {
32001   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32002
32003   arg1 = (Dali::LongPressGesture *)jarg1;
32004   {
32005     try {
32006       delete arg1;
32007     } catch (std::out_of_range& e) {
32008       {
32009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32010       };
32011     } catch (std::exception& e) {
32012       {
32013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32014       };
32015     } catch (Dali::DaliException e) {
32016       {
32017         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32018       };
32019     } catch (...) {
32020       {
32021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32022       };
32023     }
32024   }
32025
32026 }
32027
32028
32029 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
32030   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32031   unsigned int arg2 ;
32032
32033   arg1 = (Dali::LongPressGesture *)jarg1;
32034   arg2 = (unsigned int)jarg2;
32035   if (arg1) (arg1)->numberOfTouches = arg2;
32036 }
32037
32038
32039 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_get(void * jarg1) {
32040   unsigned int jresult ;
32041   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32042   unsigned int result;
32043
32044   arg1 = (Dali::LongPressGesture *)jarg1;
32045   result = (unsigned int) ((arg1)->numberOfTouches);
32046   jresult = result;
32047   return jresult;
32048 }
32049
32050
32051 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_set(void * jarg1, void * jarg2) {
32052   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32053   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
32054
32055   arg1 = (Dali::LongPressGesture *)jarg1;
32056   arg2 = (Dali::Vector2 *)jarg2;
32057   if (arg1) (arg1)->screenPoint = *arg2;
32058 }
32059
32060
32061 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_get(void * jarg1) {
32062   void * jresult ;
32063   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32064   Dali::Vector2 *result = 0 ;
32065
32066   arg1 = (Dali::LongPressGesture *)jarg1;
32067   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
32068   jresult = (void *)result;
32069   return jresult;
32070 }
32071
32072
32073 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_set(void * jarg1, void * jarg2) {
32074   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32075   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
32076
32077   arg1 = (Dali::LongPressGesture *)jarg1;
32078   arg2 = (Dali::Vector2 *)jarg2;
32079   if (arg1) (arg1)->localPoint = *arg2;
32080 }
32081
32082
32083 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_get(void * jarg1) {
32084   void * jresult ;
32085   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32086   Dali::Vector2 *result = 0 ;
32087
32088   arg1 = (Dali::LongPressGesture *)jarg1;
32089   result = (Dali::Vector2 *)& ((arg1)->localPoint);
32090   jresult = (void *)result;
32091   return jresult;
32092 }
32093
32094
32095 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_0() {
32096   void * jresult ;
32097   Dali::WheelEvent *result = 0 ;
32098
32099   {
32100     try {
32101       result = (Dali::WheelEvent *)new Dali::WheelEvent();
32102     } catch (std::out_of_range& e) {
32103       {
32104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32105       };
32106     } catch (std::exception& e) {
32107       {
32108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32109       };
32110     } catch (Dali::DaliException e) {
32111       {
32112         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32113       };
32114     } catch (...) {
32115       {
32116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32117       };
32118     }
32119   }
32120
32121   jresult = (void *)result;
32122   return jresult;
32123 }
32124
32125
32126 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_1(int jarg1, int jarg2, unsigned int jarg3, void * jarg4, int jarg5, unsigned int jarg6) {
32127   void * jresult ;
32128   Dali::WheelEvent::Type arg1 ;
32129   int arg2 ;
32130   unsigned int arg3 ;
32131   Dali::Vector2 arg4 ;
32132   int arg5 ;
32133   unsigned int arg6 ;
32134   Dali::Vector2 *argp4 ;
32135   Dali::WheelEvent *result = 0 ;
32136
32137   arg1 = (Dali::WheelEvent::Type)jarg1;
32138   arg2 = (int)jarg2;
32139   arg3 = (unsigned int)jarg3;
32140   argp4 = (Dali::Vector2 *)jarg4;
32141   if (!argp4) {
32142     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
32143     return 0;
32144   }
32145   arg4 = *argp4;
32146   arg5 = (int)jarg5;
32147   arg6 = (unsigned int)jarg6;
32148   {
32149     try {
32150       result = (Dali::WheelEvent *)new Dali::WheelEvent(arg1,arg2,arg3,arg4,arg5,arg6);
32151     } catch (std::out_of_range& e) {
32152       {
32153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32154       };
32155     } catch (std::exception& e) {
32156       {
32157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32158       };
32159     } catch (Dali::DaliException e) {
32160       {
32161         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32162       };
32163     } catch (...) {
32164       {
32165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32166       };
32167     }
32168   }
32169
32170   jresult = (void *)result;
32171   return jresult;
32172 }
32173
32174
32175 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Wheel(void * jarg1) {
32176   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32177
32178   arg1 = (Dali::WheelEvent *)jarg1;
32179   {
32180     try {
32181       delete arg1;
32182     } catch (std::out_of_range& e) {
32183       {
32184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32185       };
32186     } catch (std::exception& e) {
32187       {
32188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32189       };
32190     } catch (Dali::DaliException e) {
32191       {
32192         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32193       };
32194     } catch (...) {
32195       {
32196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32197       };
32198     }
32199   }
32200
32201 }
32202
32203
32204 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsShiftModifier(void * jarg1) {
32205   unsigned int jresult ;
32206   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32207   bool result;
32208
32209   arg1 = (Dali::WheelEvent *)jarg1;
32210   {
32211     try {
32212       result = (bool)((Dali::WheelEvent const *)arg1)->IsShiftModifier();
32213     } catch (std::out_of_range& e) {
32214       {
32215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32216       };
32217     } catch (std::exception& e) {
32218       {
32219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32220       };
32221     } catch (Dali::DaliException e) {
32222       {
32223         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32224       };
32225     } catch (...) {
32226       {
32227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32228       };
32229     }
32230   }
32231
32232   jresult = result;
32233   return jresult;
32234 }
32235
32236
32237 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsCtrlModifier(void * jarg1) {
32238   unsigned int jresult ;
32239   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32240   bool result;
32241
32242   arg1 = (Dali::WheelEvent *)jarg1;
32243   {
32244     try {
32245       result = (bool)((Dali::WheelEvent const *)arg1)->IsCtrlModifier();
32246     } catch (std::out_of_range& e) {
32247       {
32248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32249       };
32250     } catch (std::exception& e) {
32251       {
32252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32253       };
32254     } catch (Dali::DaliException e) {
32255       {
32256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32257       };
32258     } catch (...) {
32259       {
32260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32261       };
32262     }
32263   }
32264
32265   jresult = result;
32266   return jresult;
32267 }
32268
32269
32270 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsAltModifier(void * jarg1) {
32271   unsigned int jresult ;
32272   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32273   bool result;
32274
32275   arg1 = (Dali::WheelEvent *)jarg1;
32276   {
32277     try {
32278       result = (bool)((Dali::WheelEvent const *)arg1)->IsAltModifier();
32279     } catch (std::out_of_range& e) {
32280       {
32281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32282       };
32283     } catch (std::exception& e) {
32284       {
32285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32286       };
32287     } catch (Dali::DaliException e) {
32288       {
32289         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32290       };
32291     } catch (...) {
32292       {
32293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32294       };
32295     }
32296   }
32297
32298   jresult = result;
32299   return jresult;
32300 }
32301
32302
32303 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_type_set(void * jarg1, int jarg2) {
32304   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32305   Dali::WheelEvent::Type arg2 ;
32306
32307   arg1 = (Dali::WheelEvent *)jarg1;
32308   arg2 = (Dali::WheelEvent::Type)jarg2;
32309   if (arg1) (arg1)->type = arg2;
32310 }
32311
32312
32313 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_type_get(void * jarg1) {
32314   int jresult ;
32315   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32316   Dali::WheelEvent::Type result;
32317
32318   arg1 = (Dali::WheelEvent *)jarg1;
32319   result = (Dali::WheelEvent::Type) ((arg1)->type);
32320   jresult = (int)result;
32321   return jresult;
32322 }
32323
32324
32325 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_direction_set(void * jarg1, int jarg2) {
32326   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32327   int arg2 ;
32328
32329   arg1 = (Dali::WheelEvent *)jarg1;
32330   arg2 = (int)jarg2;
32331   if (arg1) (arg1)->direction = arg2;
32332 }
32333
32334
32335 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_direction_get(void * jarg1) {
32336   int jresult ;
32337   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32338   int result;
32339
32340   arg1 = (Dali::WheelEvent *)jarg1;
32341   result = (int) ((arg1)->direction);
32342   jresult = result;
32343   return jresult;
32344 }
32345
32346
32347 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_modifiers_set(void * jarg1, unsigned int jarg2) {
32348   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32349   unsigned int arg2 ;
32350
32351   arg1 = (Dali::WheelEvent *)jarg1;
32352   arg2 = (unsigned int)jarg2;
32353   if (arg1) (arg1)->modifiers = arg2;
32354 }
32355
32356
32357 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_modifiers_get(void * jarg1) {
32358   unsigned int jresult ;
32359   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32360   unsigned int result;
32361
32362   arg1 = (Dali::WheelEvent *)jarg1;
32363   result = (unsigned int) ((arg1)->modifiers);
32364   jresult = result;
32365   return jresult;
32366 }
32367
32368
32369 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_point_set(void * jarg1, void * jarg2) {
32370   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32371   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
32372
32373   arg1 = (Dali::WheelEvent *)jarg1;
32374   arg2 = (Dali::Vector2 *)jarg2;
32375   if (arg1) (arg1)->point = *arg2;
32376 }
32377
32378
32379 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Wheel_point_get(void * jarg1) {
32380   void * jresult ;
32381   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32382   Dali::Vector2 *result = 0 ;
32383
32384   arg1 = (Dali::WheelEvent *)jarg1;
32385   result = (Dali::Vector2 *)& ((arg1)->point);
32386   jresult = (void *)result;
32387   return jresult;
32388 }
32389
32390
32391 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_z_set(void * jarg1, int jarg2) {
32392   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32393   int arg2 ;
32394
32395   arg1 = (Dali::WheelEvent *)jarg1;
32396   arg2 = (int)jarg2;
32397   if (arg1) (arg1)->z = arg2;
32398 }
32399
32400
32401 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_z_get(void * jarg1) {
32402   int jresult ;
32403   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32404   int result;
32405
32406   arg1 = (Dali::WheelEvent *)jarg1;
32407   result = (int) ((arg1)->z);
32408   jresult = result;
32409   return jresult;
32410 }
32411
32412
32413 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_set(void * jarg1, unsigned int jarg2) {
32414   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32415   unsigned int arg2 ;
32416
32417   arg1 = (Dali::WheelEvent *)jarg1;
32418   arg2 = (unsigned int)jarg2;
32419   if (arg1) (arg1)->timeStamp = arg2;
32420 }
32421
32422
32423 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_get(void * jarg1) {
32424   unsigned int jresult ;
32425   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32426   unsigned int result;
32427
32428   arg1 = (Dali::WheelEvent *)jarg1;
32429   result = (unsigned int) ((arg1)->timeStamp);
32430   jresult = result;
32431   return jresult;
32432 }
32433
32434 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetDeviceName(void * jarg1) {
32435   char * jresult ;
32436   Dali::KeyEvent *arg1 = 0 ;
32437   std::string result;
32438
32439   arg1 = (Dali::KeyEvent *)jarg1;
32440   if (!arg1) {
32441     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
32442     return 0;
32443   }
32444   {
32445     try {
32446       result = arg1->GetDeviceName();
32447     } catch (std::out_of_range& e) {
32448       {
32449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32450       };
32451     } catch (std::exception& e) {
32452       {
32453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32454       };
32455     } catch (Dali::DaliException e) {
32456       {
32457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32458       };
32459     } catch (...) {
32460       {
32461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32462       };
32463     }
32464   }
32465
32466   jresult = SWIG_csharp_string_callback((&result)->c_str());
32467   return jresult;
32468 }
32469
32470 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceClass(void * jarg1) {
32471   int jresult ;
32472   Dali::KeyEvent *arg1 = 0 ;
32473   Dali::Device::Class::Type result;
32474
32475   arg1 = (Dali::KeyEvent *)jarg1;
32476   if (!arg1) {
32477     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
32478     return 0;
32479   }
32480   {
32481     try {
32482       result = (Dali::Device::Class::Type)arg1->GetDeviceClass();
32483     } catch (std::out_of_range& e) {
32484       {
32485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32486       };
32487     } catch (std::exception& e) {
32488       {
32489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32490       };
32491     } catch (Dali::DaliException e) {
32492       {
32493         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32494       };
32495     } catch (...) {
32496       {
32497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32498       };
32499     }
32500   }
32501
32502   jresult = (int)result;
32503   return jresult;
32504 }
32505
32506 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceSubClass(void * jarg1) {
32507   int jresult ;
32508   Dali::KeyEvent *arg1 = 0 ;
32509   Dali::Device::Subclass::Type result;
32510
32511   arg1 = (Dali::KeyEvent *)jarg1;
32512   if (!arg1) {
32513     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
32514     return 0;
32515   }
32516   {
32517     try {
32518       result = (Dali::Device::Subclass::Type)arg1->GetDeviceSubclass();
32519     } catch (std::out_of_range& e) {
32520       {
32521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32522       };
32523     } catch (std::exception& e) {
32524       {
32525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32526       };
32527     } catch (Dali::DaliException e) {
32528       {
32529         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32530       };
32531     } catch (...) {
32532       {
32533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32534       };
32535     }
32536   }
32537
32538   jresult = (int)result;
32539   return jresult;
32540 }
32541
32542 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Raise(void * jarg1) {
32543   Dali::Actor arg1 ;
32544   Dali::Actor *argp1 ;
32545
32546   argp1 = (Dali::Actor *)jarg1;
32547   if (!argp1) {
32548     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32549     return ;
32550   }
32551   arg1 = *argp1;
32552   {
32553     try {
32554       arg1.Raise();
32555     } catch (std::out_of_range& e) {
32556       {
32557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32558       };
32559     } catch (std::exception& e) {
32560       {
32561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32562       };
32563     } catch (Dali::DaliException e) {
32564       {
32565         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32566       };
32567     } catch (...) {
32568       {
32569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32570       };
32571     }
32572   }
32573
32574 }
32575
32576
32577 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Lower(void * jarg1) {
32578   Dali::Actor arg1 ;
32579   Dali::Actor *argp1 ;
32580
32581   argp1 = (Dali::Actor *)jarg1;
32582   if (!argp1) {
32583     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32584     return ;
32585   }
32586   arg1 = *argp1;
32587   {
32588     try {
32589       arg1.Lower();
32590     } catch (std::out_of_range& e) {
32591       {
32592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32593       };
32594     } catch (std::exception& e) {
32595       {
32596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32597       };
32598     } catch (Dali::DaliException e) {
32599       {
32600         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32601       };
32602     } catch (...) {
32603       {
32604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32605       };
32606     }
32607   }
32608
32609 }
32610
32611
32612 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseToTop(void * jarg1) {
32613   Dali::Actor arg1 ;
32614   Dali::Actor *argp1 ;
32615
32616   argp1 = (Dali::Actor *)jarg1;
32617   if (!argp1) {
32618     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32619     return ;
32620   }
32621   arg1 = *argp1;
32622   {
32623     try {
32624       arg1.RaiseToTop();
32625     } catch (std::out_of_range& e) {
32626       {
32627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32628       };
32629     } catch (std::exception& e) {
32630       {
32631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32632       };
32633     } catch (Dali::DaliException e) {
32634       {
32635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32636       };
32637     } catch (...) {
32638       {
32639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32640       };
32641     }
32642   }
32643
32644 }
32645
32646
32647 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerToBottom(void * jarg1) {
32648   Dali::Actor arg1 ;
32649   Dali::Actor *argp1 ;
32650
32651   argp1 = (Dali::Actor *)jarg1;
32652   if (!argp1) {
32653     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32654     return ;
32655   }
32656   arg1 = *argp1;
32657   {
32658     try {
32659       arg1.LowerToBottom();
32660     } catch (std::out_of_range& e) {
32661       {
32662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32663       };
32664     } catch (std::exception& e) {
32665       {
32666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32667       };
32668     } catch (Dali::DaliException e) {
32669       {
32670         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32671       };
32672     } catch (...) {
32673       {
32674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32675       };
32676     }
32677   }
32678
32679 }
32680
32681 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseAbove(void * jarg1, void * jarg2) {
32682   Dali::Actor arg1 ;
32683   Dali::Actor arg2 ;
32684   Dali::Actor *argp1 ;
32685   Dali::Actor *argp2 ;
32686
32687   argp1 = (Dali::Actor *)jarg1;
32688   if (!argp1) {
32689     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32690     return ;
32691   }
32692   arg1 = *argp1;
32693   argp2 = (Dali::Actor *)jarg2;
32694   if (!argp2) {
32695     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32696     return ;
32697   }
32698   arg2 = *argp2;
32699   {
32700     try {
32701       arg1.RaiseAbove(arg2);
32702     } catch (std::out_of_range& e) {
32703       {
32704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32705       };
32706     } catch (std::exception& e) {
32707       {
32708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32709       };
32710     } catch (Dali::DaliException e) {
32711       {
32712         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32713       };
32714     } catch (...) {
32715       {
32716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32717       };
32718     }
32719   }
32720
32721 }
32722
32723
32724 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerBelow(void * jarg1, void * jarg2) {
32725   Dali::Actor arg1 ;
32726   Dali::Actor arg2 ;
32727   Dali::Actor *argp1 ;
32728   Dali::Actor *argp2 ;
32729
32730   argp1 = (Dali::Actor *)jarg1;
32731   if (!argp1) {
32732     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32733     return ;
32734   }
32735   arg1 = *argp1;
32736   argp2 = (Dali::Actor *)jarg2;
32737   if (!argp2) {
32738     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32739     return ;
32740   }
32741   arg2 = *argp2;
32742   {
32743     try {
32744       arg1.LowerBelow(arg2);
32745     } catch (std::out_of_range& e) {
32746       {
32747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32748       };
32749     } catch (std::exception& e) {
32750       {
32751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32752       };
32753     } catch (Dali::DaliException e) {
32754       {
32755         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32756       };
32757     } catch (...) {
32758       {
32759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32760       };
32761     }
32762   }
32763
32764 }
32765
32766
32767 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisibilityChangedSignal(void * jarg1) {
32768   void * jresult ;
32769   Dali::Actor arg1 ;
32770   Dali::Actor *argp1 ;
32771   Dali::DevelActor::VisibilityChangedSignalType *result = 0 ;
32772
32773   argp1 = (Dali::Actor *)jarg1;
32774   if (!argp1) {
32775     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32776     return 0;
32777   }
32778   arg1 = *argp1;
32779   {
32780     try {
32781       result = (Dali::DevelActor::VisibilityChangedSignalType *) &Dali::DevelActor::VisibilityChangedSignal(arg1);
32782     } catch (std::out_of_range& e) {
32783       {
32784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32785       };
32786     } catch (std::exception& e) {
32787       {
32788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32789       };
32790     } catch (Dali::DaliException e) {
32791       {
32792         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32793       };
32794     } catch (...) {
32795       {
32796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32797       };
32798     }
32799   }
32800
32801   jresult = (void *)result;
32802   return jresult;
32803 }
32804
32805
32806 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutDirectionChangedSignal(void * jarg1) {
32807   void * jresult ;
32808   Dali::Actor *arg1 ;
32809   Dali::Actor::LayoutDirectionChangedSignalType *result = 0 ;
32810
32811   arg1 = (Dali::Actor *)jarg1;
32812   {
32813     try {
32814       result = (Dali::Actor::LayoutDirectionChangedSignalType *) &(arg1)->LayoutDirectionChangedSignal();
32815     } catch (std::out_of_range& e) {
32816       {
32817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32818       };
32819     } catch (std::exception& e) {
32820       {
32821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32822       };
32823     } catch (Dali::DaliException e) {
32824       {
32825         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32826       };
32827     } catch (...) {
32828       {
32829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32830       };
32831     }
32832   }
32833
32834   jresult = (void *)result;
32835   return jresult;
32836 }
32837
32838
32839 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_get() {
32840   int jresult ;
32841   int result;
32842
32843   result = (int)Dali::Actor::Property::PARENT_ORIGIN;
32844   jresult = (int)result;
32845   return jresult;
32846 }
32847
32848
32849 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_X_get() {
32850   int jresult ;
32851   int result;
32852
32853   result = (int)Dali::Actor::Property::PARENT_ORIGIN_X;
32854   jresult = (int)result;
32855   return jresult;
32856 }
32857
32858
32859 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Y_get() {
32860   int jresult ;
32861   int result;
32862
32863   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Y;
32864   jresult = (int)result;
32865   return jresult;
32866 }
32867
32868
32869 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Z_get() {
32870   int jresult ;
32871   int result;
32872
32873   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Z;
32874   jresult = (int)result;
32875   return jresult;
32876 }
32877
32878
32879 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_get() {
32880   int jresult ;
32881   int result;
32882
32883   result = (int)Dali::Actor::Property::ANCHOR_POINT;
32884   jresult = (int)result;
32885   return jresult;
32886 }
32887
32888
32889 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_X_get() {
32890   int jresult ;
32891   int result;
32892
32893   result = (int)Dali::Actor::Property::ANCHOR_POINT_X;
32894   jresult = (int)result;
32895   return jresult;
32896 }
32897
32898
32899 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Y_get() {
32900   int jresult ;
32901   int result;
32902
32903   result = (int)Dali::Actor::Property::ANCHOR_POINT_Y;
32904   jresult = (int)result;
32905   return jresult;
32906 }
32907
32908
32909 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Z_get() {
32910   int jresult ;
32911   int result;
32912
32913   result = (int)Dali::Actor::Property::ANCHOR_POINT_Z;
32914   jresult = (int)result;
32915   return jresult;
32916 }
32917
32918
32919 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_get() {
32920   int jresult ;
32921   int result;
32922
32923   result = (int)Dali::Actor::Property::SIZE;
32924   jresult = (int)result;
32925   return jresult;
32926 }
32927
32928
32929 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_WIDTH_get() {
32930   int jresult ;
32931   int result;
32932
32933   result = (int)Dali::Actor::Property::SIZE_WIDTH;
32934   jresult = (int)result;
32935   return jresult;
32936 }
32937
32938
32939 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_HEIGHT_get() {
32940   int jresult ;
32941   int result;
32942
32943   result = (int)Dali::Actor::Property::SIZE_HEIGHT;
32944   jresult = (int)result;
32945   return jresult;
32946 }
32947
32948
32949 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_DEPTH_get() {
32950   int jresult ;
32951   int result;
32952
32953   result = (int)Dali::Actor::Property::SIZE_DEPTH;
32954   jresult = (int)result;
32955   return jresult;
32956 }
32957
32958
32959 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_get() {
32960   int jresult ;
32961   int result;
32962
32963   result = (int)Dali::Actor::Property::POSITION;
32964   jresult = (int)result;
32965   return jresult;
32966 }
32967
32968
32969 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_X_get() {
32970   int jresult ;
32971   int result;
32972
32973   result = (int)Dali::Actor::Property::POSITION_X;
32974   jresult = (int)result;
32975   return jresult;
32976 }
32977
32978
32979 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Y_get() {
32980   int jresult ;
32981   int result;
32982
32983   result = (int)Dali::Actor::Property::POSITION_Y;
32984   jresult = (int)result;
32985   return jresult;
32986 }
32987
32988
32989 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Z_get() {
32990   int jresult ;
32991   int result;
32992
32993   result = (int)Dali::Actor::Property::POSITION_Z;
32994   jresult = (int)result;
32995   return jresult;
32996 }
32997
32998
32999 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_get() {
33000   int jresult ;
33001   int result;
33002
33003   result = (int)Dali::Actor::Property::WORLD_POSITION;
33004   jresult = (int)result;
33005   return jresult;
33006 }
33007
33008
33009 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_X_get() {
33010   int jresult ;
33011   int result;
33012
33013   result = (int)Dali::Actor::Property::WORLD_POSITION_X;
33014   jresult = (int)result;
33015   return jresult;
33016 }
33017
33018
33019 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Y_get() {
33020   int jresult ;
33021   int result;
33022
33023   result = (int)Dali::Actor::Property::WORLD_POSITION_Y;
33024   jresult = (int)result;
33025   return jresult;
33026 }
33027
33028
33029 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Z_get() {
33030   int jresult ;
33031   int result;
33032
33033   result = (int)Dali::Actor::Property::WORLD_POSITION_Z;
33034   jresult = (int)result;
33035   return jresult;
33036 }
33037
33038
33039 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ORIENTATION_get() {
33040   int jresult ;
33041   int result;
33042
33043   result = (int)Dali::Actor::Property::ORIENTATION;
33044   jresult = (int)result;
33045   return jresult;
33046 }
33047
33048
33049 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_ORIENTATION_get() {
33050   int jresult ;
33051   int result;
33052
33053   result = (int)Dali::Actor::Property::WORLD_ORIENTATION;
33054   jresult = (int)result;
33055   return jresult;
33056 }
33057
33058
33059 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_get() {
33060   int jresult ;
33061   int result;
33062
33063   result = (int)Dali::Actor::Property::SCALE;
33064   jresult = (int)result;
33065   return jresult;
33066 }
33067
33068
33069 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_X_get() {
33070   int jresult ;
33071   int result;
33072
33073   result = (int)Dali::Actor::Property::SCALE_X;
33074   jresult = (int)result;
33075   return jresult;
33076 }
33077
33078
33079 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Y_get() {
33080   int jresult ;
33081   int result;
33082
33083   result = (int)Dali::Actor::Property::SCALE_Y;
33084   jresult = (int)result;
33085   return jresult;
33086 }
33087
33088
33089 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Z_get() {
33090   int jresult ;
33091   int result;
33092
33093   result = (int)Dali::Actor::Property::SCALE_Z;
33094   jresult = (int)result;
33095   return jresult;
33096 }
33097
33098
33099 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_SCALE_get() {
33100   int jresult ;
33101   int result;
33102
33103   result = (int)Dali::Actor::Property::WORLD_SCALE;
33104   jresult = (int)result;
33105   return jresult;
33106 }
33107
33108
33109 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_VISIBLE_get() {
33110   int jresult ;
33111   int result;
33112
33113   result = (int)Dali::Actor::Property::VISIBLE;
33114   jresult = (int)result;
33115   return jresult;
33116 }
33117
33118
33119 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_get() {
33120   int jresult ;
33121   int result;
33122
33123   result = (int)Dali::Actor::Property::COLOR;
33124   jresult = (int)result;
33125   return jresult;
33126 }
33127
33128
33129 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_RED_get() {
33130   int jresult ;
33131   int result;
33132
33133   result = (int)Dali::Actor::Property::COLOR_RED;
33134   jresult = (int)result;
33135   return jresult;
33136 }
33137
33138
33139 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_GREEN_get() {
33140   int jresult ;
33141   int result;
33142
33143   result = (int)Dali::Actor::Property::COLOR_GREEN;
33144   jresult = (int)result;
33145   return jresult;
33146 }
33147
33148
33149 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_BLUE_get() {
33150   int jresult ;
33151   int result;
33152
33153   result = (int)Dali::Actor::Property::COLOR_BLUE;
33154   jresult = (int)result;
33155   return jresult;
33156 }
33157
33158
33159 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_ALPHA_get() {
33160   int jresult ;
33161   int result;
33162
33163   result = (int)Dali::Actor::Property::COLOR_ALPHA;
33164   jresult = (int)result;
33165   return jresult;
33166 }
33167
33168
33169 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_COLOR_get() {
33170   int jresult ;
33171   int result;
33172
33173   result = (int)Dali::Actor::Property::WORLD_COLOR;
33174   jresult = (int)result;
33175   return jresult;
33176 }
33177
33178
33179 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_MATRIX_get() {
33180   int jresult ;
33181   int result;
33182
33183   result = (int)Dali::Actor::Property::WORLD_MATRIX;
33184   jresult = (int)result;
33185   return jresult;
33186 }
33187
33188
33189 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_NAME_get() {
33190   int jresult ;
33191   int result;
33192
33193   result = (int)Dali::Actor::Property::NAME;
33194   jresult = (int)result;
33195   return jresult;
33196 }
33197
33198
33199 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SENSITIVE_get() {
33200   int jresult ;
33201   int result;
33202
33203   result = (int)Dali::Actor::Property::SENSITIVE;
33204   jresult = (int)result;
33205   return jresult;
33206 }
33207
33208
33209 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_LEAVE_REQUIRED_get() {
33210   int jresult ;
33211   int result;
33212
33213   result = (int)Dali::Actor::Property::LEAVE_REQUIRED;
33214   jresult = (int)result;
33215   return jresult;
33216 }
33217
33218
33219 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_ORIENTATION_get() {
33220   int jresult ;
33221   int result;
33222
33223   result = (int)Dali::Actor::Property::INHERIT_ORIENTATION;
33224   jresult = (int)result;
33225   return jresult;
33226 }
33227
33228
33229 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_SCALE_get() {
33230   int jresult ;
33231   int result;
33232
33233   result = (int)Dali::Actor::Property::INHERIT_SCALE;
33234   jresult = (int)result;
33235   return jresult;
33236 }
33237
33238
33239 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_MODE_get() {
33240   int jresult ;
33241   int result;
33242
33243   result = (int)Dali::Actor::Property::COLOR_MODE;
33244   jresult = (int)result;
33245   return jresult;
33246 }
33247
33248
33249 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_DRAW_MODE_get() {
33250   int jresult ;
33251   int result;
33252
33253   result = (int)Dali::Actor::Property::DRAW_MODE;
33254   jresult = (int)result;
33255   return jresult;
33256 }
33257
33258
33259 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_MODE_FACTOR_get() {
33260   int jresult ;
33261   int result;
33262
33263   result = (int)Dali::Actor::Property::SIZE_MODE_FACTOR;
33264   jresult = (int)result;
33265   return jresult;
33266 }
33267
33268
33269 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_RESIZE_POLICY_get() {
33270   int jresult ;
33271   int result;
33272
33273   result = (int)Dali::Actor::Property::WIDTH_RESIZE_POLICY;
33274   jresult = (int)result;
33275   return jresult;
33276 }
33277
33278
33279 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_RESIZE_POLICY_get() {
33280   int jresult ;
33281   int result;
33282
33283   result = (int)Dali::Actor::Property::HEIGHT_RESIZE_POLICY;
33284   jresult = (int)result;
33285   return jresult;
33286 }
33287
33288
33289 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_SCALE_POLICY_get() {
33290   int jresult ;
33291   int result;
33292
33293   result = (int)Dali::Actor::Property::SIZE_SCALE_POLICY;
33294   jresult = (int)result;
33295   return jresult;
33296 }
33297
33298
33299 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_FOR_HEIGHT_get() {
33300   int jresult ;
33301   int result;
33302
33303   result = (int)Dali::Actor::Property::WIDTH_FOR_HEIGHT;
33304   jresult = (int)result;
33305   return jresult;
33306 }
33307
33308
33309 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_FOR_WIDTH_get() {
33310   int jresult ;
33311   int result;
33312
33313   result = (int)Dali::Actor::Property::HEIGHT_FOR_WIDTH;
33314   jresult = (int)result;
33315   return jresult;
33316 }
33317
33318
33319 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PADDING_get() {
33320   int jresult ;
33321   int result;
33322
33323   result = (int)Dali::Actor::Property::PADDING;
33324   jresult = (int)result;
33325   return jresult;
33326 }
33327
33328
33329 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MINIMUM_SIZE_get() {
33330   int jresult ;
33331   int result;
33332
33333   result = (int)Dali::Actor::Property::MINIMUM_SIZE;
33334   jresult = (int)result;
33335   return jresult;
33336 }
33337
33338
33339 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MAXIMUM_SIZE_get() {
33340   int jresult ;
33341   int result;
33342
33343   result = (int)Dali::Actor::Property::MAXIMUM_SIZE;
33344   jresult = (int)result;
33345   return jresult;
33346 }
33347
33348
33349 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_POSITION_get() {
33350   int jresult ;
33351   int result;
33352
33353   result = (int)Dali::Actor::Property::INHERIT_POSITION;
33354   jresult = (int)result;
33355   return jresult;
33356 }
33357
33358
33359 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_CLIPPING_MODE_get() {
33360   int jresult ;
33361   int result;
33362
33363   result = (int)Dali::Actor::Property::CLIPPING_MODE;
33364   jresult = (int)result;
33365   return jresult;
33366 }
33367
33368
33369 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor_Property() {
33370   void * jresult ;
33371   Dali::Actor::Property *result = 0 ;
33372
33373   {
33374     try {
33375       result = (Dali::Actor::Property *)new Dali::Actor::Property();
33376     } catch (std::out_of_range& e) {
33377       {
33378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33379       };
33380     } catch (std::exception& e) {
33381       {
33382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33383       };
33384     } catch (Dali::DaliException e) {
33385       {
33386         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33387       };
33388     } catch (...) {
33389       {
33390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33391       };
33392     }
33393   }
33394
33395   jresult = (void *)result;
33396   return jresult;
33397 }
33398
33399
33400 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor_Property(void * jarg1) {
33401   Dali::Actor::Property *arg1 = (Dali::Actor::Property *) 0 ;
33402
33403   arg1 = (Dali::Actor::Property *)jarg1;
33404   {
33405     try {
33406       delete arg1;
33407     } catch (std::out_of_range& e) {
33408       {
33409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33410       };
33411     } catch (std::exception& e) {
33412       {
33413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33414       };
33415     } catch (Dali::DaliException e) {
33416       {
33417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33418       };
33419     } catch (...) {
33420       {
33421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33422       };
33423     }
33424   }
33425
33426 }
33427
33428
33429 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_0() {
33430   void * jresult ;
33431   Dali::Actor *result = 0 ;
33432
33433   {
33434     try {
33435       result = (Dali::Actor *)new Dali::Actor();
33436     } catch (std::out_of_range& e) {
33437       {
33438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33439       };
33440     } catch (std::exception& e) {
33441       {
33442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33443       };
33444     } catch (Dali::DaliException e) {
33445       {
33446         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33447       };
33448     } catch (...) {
33449       {
33450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33451       };
33452     }
33453   }
33454
33455   jresult = (void *)result;
33456   return jresult;
33457 }
33458
33459
33460 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_New() {
33461   void * jresult ;
33462   Dali::Actor result;
33463
33464   {
33465     try {
33466       result = Dali::Actor::New();
33467     } catch (std::out_of_range& e) {
33468       {
33469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33470       };
33471     } catch (std::exception& e) {
33472       {
33473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33474       };
33475     } catch (Dali::DaliException e) {
33476       {
33477         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33478       };
33479     } catch (...) {
33480       {
33481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33482       };
33483     }
33484   }
33485
33486   jresult = new Dali::Actor((const Dali::Actor &)result);
33487   return jresult;
33488 }
33489
33490
33491 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_DownCast(void * jarg1) {
33492   void * jresult ;
33493   Dali::BaseHandle arg1 ;
33494   Dali::BaseHandle *argp1 ;
33495   Dali::Actor result;
33496
33497   argp1 = (Dali::BaseHandle *)jarg1;
33498   if (!argp1) {
33499     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
33500     return 0;
33501   }
33502   arg1 = *argp1;
33503   {
33504     try {
33505       result = Dali::Actor::DownCast(arg1);
33506     } catch (std::out_of_range& e) {
33507       {
33508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33509       };
33510     } catch (std::exception& e) {
33511       {
33512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33513       };
33514     } catch (Dali::DaliException e) {
33515       {
33516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33517       };
33518     } catch (...) {
33519       {
33520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33521       };
33522     }
33523   }
33524
33525   jresult = new Dali::Actor((const Dali::Actor &)result);
33526   return jresult;
33527 }
33528
33529
33530 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor(void * jarg1) {
33531   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33532
33533   arg1 = (Dali::Actor *)jarg1;
33534   {
33535     try {
33536       delete arg1;
33537     } catch (std::out_of_range& e) {
33538       {
33539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33540       };
33541     } catch (std::exception& e) {
33542       {
33543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33544       };
33545     } catch (Dali::DaliException e) {
33546       {
33547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33548       };
33549     } catch (...) {
33550       {
33551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33552       };
33553     }
33554   }
33555
33556 }
33557
33558
33559 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_1(void * jarg1) {
33560   void * jresult ;
33561   Dali::Actor *arg1 = 0 ;
33562   Dali::Actor *result = 0 ;
33563
33564   arg1 = (Dali::Actor *)jarg1;
33565   if (!arg1) {
33566     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
33567     return 0;
33568   }
33569   {
33570     try {
33571       result = (Dali::Actor *)new Dali::Actor((Dali::Actor const &)*arg1);
33572     } catch (std::out_of_range& e) {
33573       {
33574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33575       };
33576     } catch (std::exception& e) {
33577       {
33578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33579       };
33580     } catch (Dali::DaliException e) {
33581       {
33582         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33583       };
33584     } catch (...) {
33585       {
33586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33587       };
33588     }
33589   }
33590
33591   jresult = (void *)result;
33592   return jresult;
33593 }
33594
33595
33596 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_Assign(void * jarg1, void * jarg2) {
33597   void * jresult ;
33598   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33599   Dali::Actor *arg2 = 0 ;
33600   Dali::Actor *result = 0 ;
33601
33602   arg1 = (Dali::Actor *)jarg1;
33603   arg2 = (Dali::Actor *)jarg2;
33604   if (!arg2) {
33605     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
33606     return 0;
33607   }
33608   {
33609     try {
33610       result = (Dali::Actor *) &(arg1)->operator =((Dali::Actor const &)*arg2);
33611     } catch (std::out_of_range& e) {
33612       {
33613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33614       };
33615     } catch (std::exception& e) {
33616       {
33617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33618       };
33619     } catch (Dali::DaliException e) {
33620       {
33621         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33622       };
33623     } catch (...) {
33624       {
33625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33626       };
33627     }
33628   }
33629
33630   jresult = (void *)result;
33631   return jresult;
33632 }
33633
33634
33635 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Actor_GetName(void * jarg1) {
33636   char * jresult ;
33637   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33638   std::string *result = 0 ;
33639
33640   arg1 = (Dali::Actor *)jarg1;
33641   {
33642     try {
33643       result = (std::string *) &((Dali::Actor const *)arg1)->GetName();
33644     } catch (std::out_of_range& e) {
33645       {
33646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33647       };
33648     } catch (std::exception& e) {
33649       {
33650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33651       };
33652     } catch (Dali::DaliException e) {
33653       {
33654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33655       };
33656     } catch (...) {
33657       {
33658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33659       };
33660     }
33661   }
33662
33663   jresult = SWIG_csharp_string_callback(result->c_str());
33664   return jresult;
33665 }
33666
33667
33668 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetName(void * jarg1, char * jarg2) {
33669   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33670   std::string *arg2 = 0 ;
33671
33672   arg1 = (Dali::Actor *)jarg1;
33673   if (!jarg2) {
33674     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
33675     return ;
33676   }
33677   std::string arg2_str(jarg2);
33678   arg2 = &arg2_str;
33679   {
33680     try {
33681       (arg1)->SetName((std::string const &)*arg2);
33682     } catch (std::out_of_range& e) {
33683       {
33684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33685       };
33686     } catch (std::exception& e) {
33687       {
33688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33689       };
33690     } catch (Dali::DaliException e) {
33691       {
33692         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33693       };
33694     } catch (...) {
33695       {
33696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33697       };
33698     }
33699   }
33700
33701
33702   //argout typemap for const std::string&
33703
33704 }
33705
33706
33707 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetId(void * jarg1) {
33708   unsigned int jresult ;
33709   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33710   unsigned int result;
33711
33712   arg1 = (Dali::Actor *)jarg1;
33713   {
33714     try {
33715       result = (unsigned int)((Dali::Actor const *)arg1)->GetId();
33716     } catch (std::out_of_range& e) {
33717       {
33718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33719       };
33720     } catch (std::exception& e) {
33721       {
33722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33723       };
33724     } catch (Dali::DaliException e) {
33725       {
33726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33727       };
33728     } catch (...) {
33729       {
33730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33731       };
33732     }
33733   }
33734
33735   jresult = result;
33736   return jresult;
33737 }
33738
33739
33740 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsRoot(void * jarg1) {
33741   unsigned int jresult ;
33742   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33743   bool result;
33744
33745   arg1 = (Dali::Actor *)jarg1;
33746   {
33747     try {
33748       result = (bool)((Dali::Actor const *)arg1)->IsRoot();
33749     } catch (std::out_of_range& e) {
33750       {
33751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33752       };
33753     } catch (std::exception& e) {
33754       {
33755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33756       };
33757     } catch (Dali::DaliException e) {
33758       {
33759         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33760       };
33761     } catch (...) {
33762       {
33763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33764       };
33765     }
33766   }
33767
33768   jresult = result;
33769   return jresult;
33770 }
33771
33772
33773 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_OnStage(void * jarg1) {
33774   unsigned int jresult ;
33775   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33776   bool result;
33777
33778   arg1 = (Dali::Actor *)jarg1;
33779   {
33780     try {
33781       result = (bool)((Dali::Actor const *)arg1)->OnStage();
33782     } catch (std::out_of_range& e) {
33783       {
33784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33785       };
33786     } catch (std::exception& e) {
33787       {
33788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33789       };
33790     } catch (Dali::DaliException e) {
33791       {
33792         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33793       };
33794     } catch (...) {
33795       {
33796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33797       };
33798     }
33799   }
33800
33801   jresult = result;
33802   return jresult;
33803 }
33804
33805
33806 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsLayer(void * jarg1) {
33807   unsigned int jresult ;
33808   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33809   bool result;
33810
33811   arg1 = (Dali::Actor *)jarg1;
33812   {
33813     try {
33814       result = (bool)((Dali::Actor const *)arg1)->IsLayer();
33815     } catch (std::out_of_range& e) {
33816       {
33817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33818       };
33819     } catch (std::exception& e) {
33820       {
33821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33822       };
33823     } catch (Dali::DaliException e) {
33824       {
33825         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33826       };
33827     } catch (...) {
33828       {
33829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33830       };
33831     }
33832   }
33833
33834   jresult = result;
33835   return jresult;
33836 }
33837
33838
33839 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetLayer(void * jarg1) {
33840   void * jresult ;
33841   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33842   Dali::Layer result;
33843
33844   arg1 = (Dali::Actor *)jarg1;
33845   {
33846     try {
33847       result = (arg1)->GetLayer();
33848     } catch (std::out_of_range& e) {
33849       {
33850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33851       };
33852     } catch (std::exception& e) {
33853       {
33854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33855       };
33856     } catch (Dali::DaliException e) {
33857       {
33858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33859       };
33860     } catch (...) {
33861       {
33862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33863       };
33864     }
33865   }
33866
33867   jresult = new Dali::Layer((const Dali::Layer &)result);
33868   return jresult;
33869 }
33870
33871
33872 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Add(void * jarg1, void * jarg2) {
33873   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33874   Dali::Actor arg2 ;
33875   Dali::Actor *argp2 ;
33876
33877   arg1 = (Dali::Actor *)jarg1;
33878   argp2 = (Dali::Actor *)jarg2;
33879   if (!argp2) {
33880     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
33881     return ;
33882   }
33883   arg2 = *argp2;
33884   {
33885     try {
33886       (arg1)->Add(arg2);
33887     } catch (std::out_of_range& e) {
33888       {
33889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33890       };
33891     } catch (std::exception& e) {
33892       {
33893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33894       };
33895     } catch (Dali::DaliException e) {
33896       {
33897         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33898       };
33899     } catch (...) {
33900       {
33901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33902       };
33903     }
33904   }
33905
33906 }
33907
33908
33909 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Remove(void * jarg1, void * jarg2) {
33910   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33911   Dali::Actor arg2 ;
33912   Dali::Actor *argp2 ;
33913
33914   arg1 = (Dali::Actor *)jarg1;
33915   argp2 = (Dali::Actor *)jarg2;
33916   if (!argp2) {
33917     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
33918     return ;
33919   }
33920   arg2 = *argp2;
33921   {
33922     try {
33923       (arg1)->Remove(arg2);
33924     } catch (std::out_of_range& e) {
33925       {
33926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33927       };
33928     } catch (std::exception& e) {
33929       {
33930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33931       };
33932     } catch (Dali::DaliException e) {
33933       {
33934         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33935       };
33936     } catch (...) {
33937       {
33938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33939       };
33940     }
33941   }
33942
33943 }
33944
33945
33946 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Unparent(void * jarg1) {
33947   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33948
33949   arg1 = (Dali::Actor *)jarg1;
33950   {
33951     try {
33952       (arg1)->Unparent();
33953     } catch (std::out_of_range& e) {
33954       {
33955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33956       };
33957     } catch (std::exception& e) {
33958       {
33959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33960       };
33961     } catch (Dali::DaliException e) {
33962       {
33963         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33964       };
33965     } catch (...) {
33966       {
33967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33968       };
33969     }
33970   }
33971
33972 }
33973
33974
33975 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetChildCount(void * jarg1) {
33976   unsigned int jresult ;
33977   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33978   unsigned int result;
33979
33980   arg1 = (Dali::Actor *)jarg1;
33981   {
33982     try {
33983       result = (unsigned int)((Dali::Actor const *)arg1)->GetChildCount();
33984     } catch (std::out_of_range& e) {
33985       {
33986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33987       };
33988     } catch (std::exception& e) {
33989       {
33990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33991       };
33992     } catch (Dali::DaliException e) {
33993       {
33994         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33995       };
33996     } catch (...) {
33997       {
33998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33999       };
34000     }
34001   }
34002
34003   jresult = result;
34004   return jresult;
34005 }
34006
34007
34008 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetChildAt(void * jarg1, unsigned int jarg2) {
34009   void * jresult ;
34010   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34011   unsigned int arg2 ;
34012   Dali::Actor result;
34013
34014   arg1 = (Dali::Actor *)jarg1;
34015   arg2 = (unsigned int)jarg2;
34016   {
34017     try {
34018       result = ((Dali::Actor const *)arg1)->GetChildAt(arg2);
34019     } catch (std::out_of_range& e) {
34020       {
34021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34022       };
34023     } catch (std::exception& e) {
34024       {
34025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34026       };
34027     } catch (Dali::DaliException e) {
34028       {
34029         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34030       };
34031     } catch (...) {
34032       {
34033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34034       };
34035     }
34036   }
34037
34038   jresult = new Dali::Actor((const Dali::Actor &)result);
34039   return jresult;
34040 }
34041
34042
34043 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildByName(void * jarg1, char * jarg2) {
34044   void * jresult ;
34045   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34046   std::string *arg2 = 0 ;
34047   Dali::Actor result;
34048
34049   arg1 = (Dali::Actor *)jarg1;
34050   if (!jarg2) {
34051     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
34052     return 0;
34053   }
34054   std::string arg2_str(jarg2);
34055   arg2 = &arg2_str;
34056   {
34057     try {
34058       result = (arg1)->FindChildByName((std::string const &)*arg2);
34059     } catch (std::out_of_range& e) {
34060       {
34061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34062       };
34063     } catch (std::exception& e) {
34064       {
34065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34066       };
34067     } catch (Dali::DaliException e) {
34068       {
34069         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34070       };
34071     } catch (...) {
34072       {
34073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34074       };
34075     }
34076   }
34077
34078   jresult = new Dali::Actor((const Dali::Actor &)result);
34079
34080   //argout typemap for const std::string&
34081
34082   return jresult;
34083 }
34084
34085
34086 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildById(void * jarg1, unsigned int jarg2) {
34087   void * jresult ;
34088   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34089   unsigned int arg2 ;
34090   Dali::Actor result;
34091
34092   arg1 = (Dali::Actor *)jarg1;
34093   arg2 = (unsigned int)jarg2;
34094   {
34095     try {
34096       result = (arg1)->FindChildById(arg2);
34097     } catch (std::out_of_range& e) {
34098       {
34099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34100       };
34101     } catch (std::exception& e) {
34102       {
34103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34104       };
34105     } catch (Dali::DaliException e) {
34106       {
34107         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34108       };
34109     } catch (...) {
34110       {
34111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34112       };
34113     }
34114   }
34115
34116   jresult = new Dali::Actor((const Dali::Actor &)result);
34117   return jresult;
34118 }
34119
34120
34121 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetParent(void * jarg1) {
34122   void * jresult ;
34123   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34124   Dali::Actor result;
34125
34126   arg1 = (Dali::Actor *)jarg1;
34127   {
34128     try {
34129       result = ((Dali::Actor const *)arg1)->GetParent();
34130     } catch (std::out_of_range& e) {
34131       {
34132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34133       };
34134     } catch (std::exception& e) {
34135       {
34136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34137       };
34138     } catch (Dali::DaliException e) {
34139       {
34140         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34141       };
34142     } catch (...) {
34143       {
34144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34145       };
34146     }
34147   }
34148
34149   jresult = new Dali::Actor((const Dali::Actor &)result);
34150   return jresult;
34151 }
34152
34153
34154 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetParentOrigin(void * jarg1, void * jarg2) {
34155   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34156   Dali::Vector3 *arg2 = 0 ;
34157
34158   arg1 = (Dali::Actor *)jarg1;
34159   arg2 = (Dali::Vector3 *)jarg2;
34160   if (!arg2) {
34161     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34162     return ;
34163   }
34164   {
34165     try {
34166       (arg1)->SetParentOrigin((Dali::Vector3 const &)*arg2);
34167     } catch (std::out_of_range& e) {
34168       {
34169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34170       };
34171     } catch (std::exception& e) {
34172       {
34173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34174       };
34175     } catch (Dali::DaliException e) {
34176       {
34177         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34178       };
34179     } catch (...) {
34180       {
34181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34182       };
34183     }
34184   }
34185
34186 }
34187
34188
34189 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentParentOrigin(void * jarg1) {
34190   void * jresult ;
34191   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34192   Dali::Vector3 result;
34193
34194   arg1 = (Dali::Actor *)jarg1;
34195   {
34196     try {
34197       result = ((Dali::Actor const *)arg1)->GetCurrentParentOrigin();
34198     } catch (std::out_of_range& e) {
34199       {
34200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34201       };
34202     } catch (std::exception& e) {
34203       {
34204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34205       };
34206     } catch (Dali::DaliException e) {
34207       {
34208         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34209       };
34210     } catch (...) {
34211       {
34212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34213       };
34214     }
34215   }
34216
34217   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34218   return jresult;
34219 }
34220
34221
34222 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetAnchorPoint(void * jarg1, void * jarg2) {
34223   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34224   Dali::Vector3 *arg2 = 0 ;
34225
34226   arg1 = (Dali::Actor *)jarg1;
34227   arg2 = (Dali::Vector3 *)jarg2;
34228   if (!arg2) {
34229     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34230     return ;
34231   }
34232   {
34233     try {
34234       (arg1)->SetAnchorPoint((Dali::Vector3 const &)*arg2);
34235     } catch (std::out_of_range& e) {
34236       {
34237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34238       };
34239     } catch (std::exception& e) {
34240       {
34241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34242       };
34243     } catch (Dali::DaliException e) {
34244       {
34245         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34246       };
34247     } catch (...) {
34248       {
34249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34250       };
34251     }
34252   }
34253
34254 }
34255
34256
34257 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentAnchorPoint(void * jarg1) {
34258   void * jresult ;
34259   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34260   Dali::Vector3 result;
34261
34262   arg1 = (Dali::Actor *)jarg1;
34263   {
34264     try {
34265       result = ((Dali::Actor const *)arg1)->GetCurrentAnchorPoint();
34266     } catch (std::out_of_range& e) {
34267       {
34268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34269       };
34270     } catch (std::exception& e) {
34271       {
34272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34273       };
34274     } catch (Dali::DaliException e) {
34275       {
34276         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34277       };
34278     } catch (...) {
34279       {
34280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34281       };
34282     }
34283   }
34284
34285   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34286   return jresult;
34287 }
34288
34289
34290 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_0(void * jarg1, float jarg2, float jarg3) {
34291   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34292   float arg2 ;
34293   float arg3 ;
34294
34295   arg1 = (Dali::Actor *)jarg1;
34296   arg2 = (float)jarg2;
34297   arg3 = (float)jarg3;
34298   {
34299     try {
34300       (arg1)->SetSize(arg2,arg3);
34301     } catch (std::out_of_range& e) {
34302       {
34303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34304       };
34305     } catch (std::exception& e) {
34306       {
34307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34308       };
34309     } catch (Dali::DaliException e) {
34310       {
34311         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34312       };
34313     } catch (...) {
34314       {
34315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34316       };
34317     }
34318   }
34319
34320 }
34321
34322
34323 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
34324   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34325   float arg2 ;
34326   float arg3 ;
34327   float arg4 ;
34328
34329   arg1 = (Dali::Actor *)jarg1;
34330   arg2 = (float)jarg2;
34331   arg3 = (float)jarg3;
34332   arg4 = (float)jarg4;
34333   {
34334     try {
34335       (arg1)->SetSize(arg2,arg3,arg4);
34336     } catch (std::out_of_range& e) {
34337       {
34338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34339       };
34340     } catch (std::exception& e) {
34341       {
34342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34343       };
34344     } catch (Dali::DaliException e) {
34345       {
34346         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34347       };
34348     } catch (...) {
34349       {
34350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34351       };
34352     }
34353   }
34354
34355 }
34356
34357
34358 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_2(void * jarg1, void * jarg2) {
34359   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34360   Dali::Vector2 *arg2 = 0 ;
34361
34362   arg1 = (Dali::Actor *)jarg1;
34363   arg2 = (Dali::Vector2 *)jarg2;
34364   if (!arg2) {
34365     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
34366     return ;
34367   }
34368   {
34369     try {
34370       (arg1)->SetSize((Dali::Vector2 const &)*arg2);
34371     } catch (std::out_of_range& e) {
34372       {
34373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34374       };
34375     } catch (std::exception& e) {
34376       {
34377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34378       };
34379     } catch (Dali::DaliException e) {
34380       {
34381         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34382       };
34383     } catch (...) {
34384       {
34385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34386       };
34387     }
34388   }
34389
34390 }
34391
34392
34393 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_3(void * jarg1, void * jarg2) {
34394   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34395   Dali::Vector3 *arg2 = 0 ;
34396
34397   arg1 = (Dali::Actor *)jarg1;
34398   arg2 = (Dali::Vector3 *)jarg2;
34399   if (!arg2) {
34400     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34401     return ;
34402   }
34403   {
34404     try {
34405       (arg1)->SetSize((Dali::Vector3 const &)*arg2);
34406     } catch (std::out_of_range& e) {
34407       {
34408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34409       };
34410     } catch (std::exception& e) {
34411       {
34412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34413       };
34414     } catch (Dali::DaliException e) {
34415       {
34416         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34417       };
34418     } catch (...) {
34419       {
34420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34421       };
34422     }
34423   }
34424
34425 }
34426
34427
34428 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetTargetSize(void * jarg1) {
34429   void * jresult ;
34430   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34431   Dali::Vector3 result;
34432
34433   arg1 = (Dali::Actor *)jarg1;
34434   {
34435     try {
34436       result = ((Dali::Actor const *)arg1)->GetTargetSize();
34437     } catch (std::out_of_range& e) {
34438       {
34439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34440       };
34441     } catch (std::exception& e) {
34442       {
34443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34444       };
34445     } catch (Dali::DaliException e) {
34446       {
34447         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34448       };
34449     } catch (...) {
34450       {
34451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34452       };
34453     }
34454   }
34455
34456   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34457   return jresult;
34458 }
34459
34460
34461 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentSize(void * jarg1) {
34462   void * jresult ;
34463   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34464   Dali::Vector3 result;
34465
34466   arg1 = (Dali::Actor *)jarg1;
34467   {
34468     try {
34469       result = ((Dali::Actor const *)arg1)->GetCurrentSize();
34470     } catch (std::out_of_range& e) {
34471       {
34472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34473       };
34474     } catch (std::exception& e) {
34475       {
34476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34477       };
34478     } catch (Dali::DaliException e) {
34479       {
34480         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34481       };
34482     } catch (...) {
34483       {
34484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34485       };
34486     }
34487   }
34488
34489   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34490   return jresult;
34491 }
34492
34493
34494 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetNaturalSize(void * jarg1) {
34495   void * jresult ;
34496   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34497   Dali::Vector3 result;
34498
34499   arg1 = (Dali::Actor *)jarg1;
34500   {
34501     try {
34502       result = ((Dali::Actor const *)arg1)->GetNaturalSize();
34503     } catch (std::out_of_range& e) {
34504       {
34505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34506       };
34507     } catch (std::exception& e) {
34508       {
34509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34510       };
34511     } catch (Dali::DaliException e) {
34512       {
34513         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34514       };
34515     } catch (...) {
34516       {
34517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34518       };
34519     }
34520   }
34521
34522   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34523   return jresult;
34524 }
34525
34526
34527 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_0(void * jarg1, float jarg2, float jarg3) {
34528   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34529   float arg2 ;
34530   float arg3 ;
34531
34532   arg1 = (Dali::Actor *)jarg1;
34533   arg2 = (float)jarg2;
34534   arg3 = (float)jarg3;
34535   {
34536     try {
34537       (arg1)->SetPosition(arg2,arg3);
34538     } catch (std::out_of_range& e) {
34539       {
34540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34541       };
34542     } catch (std::exception& e) {
34543       {
34544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34545       };
34546     } catch (Dali::DaliException e) {
34547       {
34548         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34549       };
34550     } catch (...) {
34551       {
34552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34553       };
34554     }
34555   }
34556
34557 }
34558
34559
34560 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
34561   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34562   float arg2 ;
34563   float arg3 ;
34564   float arg4 ;
34565
34566   arg1 = (Dali::Actor *)jarg1;
34567   arg2 = (float)jarg2;
34568   arg3 = (float)jarg3;
34569   arg4 = (float)jarg4;
34570   {
34571     try {
34572       (arg1)->SetPosition(arg2,arg3,arg4);
34573     } catch (std::out_of_range& e) {
34574       {
34575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34576       };
34577     } catch (std::exception& e) {
34578       {
34579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34580       };
34581     } catch (Dali::DaliException e) {
34582       {
34583         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34584       };
34585     } catch (...) {
34586       {
34587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34588       };
34589     }
34590   }
34591
34592 }
34593
34594
34595 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_2(void * jarg1, void * jarg2) {
34596   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34597   Dali::Vector3 *arg2 = 0 ;
34598
34599   arg1 = (Dali::Actor *)jarg1;
34600   arg2 = (Dali::Vector3 *)jarg2;
34601   if (!arg2) {
34602     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34603     return ;
34604   }
34605   {
34606     try {
34607       (arg1)->SetPosition((Dali::Vector3 const &)*arg2);
34608     } catch (std::out_of_range& e) {
34609       {
34610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34611       };
34612     } catch (std::exception& e) {
34613       {
34614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34615       };
34616     } catch (Dali::DaliException e) {
34617       {
34618         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34619       };
34620     } catch (...) {
34621       {
34622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34623       };
34624     }
34625   }
34626
34627 }
34628
34629
34630 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetX(void * jarg1, float jarg2) {
34631   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34632   float arg2 ;
34633
34634   arg1 = (Dali::Actor *)jarg1;
34635   arg2 = (float)jarg2;
34636   {
34637     try {
34638       (arg1)->SetX(arg2);
34639     } catch (std::out_of_range& e) {
34640       {
34641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34642       };
34643     } catch (std::exception& e) {
34644       {
34645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34646       };
34647     } catch (Dali::DaliException e) {
34648       {
34649         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34650       };
34651     } catch (...) {
34652       {
34653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34654       };
34655     }
34656   }
34657
34658 }
34659
34660
34661 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetY(void * jarg1, float jarg2) {
34662   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34663   float arg2 ;
34664
34665   arg1 = (Dali::Actor *)jarg1;
34666   arg2 = (float)jarg2;
34667   {
34668     try {
34669       (arg1)->SetY(arg2);
34670     } catch (std::out_of_range& e) {
34671       {
34672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34673       };
34674     } catch (std::exception& e) {
34675       {
34676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34677       };
34678     } catch (Dali::DaliException e) {
34679       {
34680         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34681       };
34682     } catch (...) {
34683       {
34684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34685       };
34686     }
34687   }
34688
34689 }
34690
34691
34692 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetZ(void * jarg1, float jarg2) {
34693   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34694   float arg2 ;
34695
34696   arg1 = (Dali::Actor *)jarg1;
34697   arg2 = (float)jarg2;
34698   {
34699     try {
34700       (arg1)->SetZ(arg2);
34701     } catch (std::out_of_range& e) {
34702       {
34703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34704       };
34705     } catch (std::exception& e) {
34706       {
34707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34708       };
34709     } catch (Dali::DaliException e) {
34710       {
34711         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34712       };
34713     } catch (...) {
34714       {
34715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34716       };
34717     }
34718   }
34719
34720 }
34721
34722
34723 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_TranslateBy(void * jarg1, void * jarg2) {
34724   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34725   Dali::Vector3 *arg2 = 0 ;
34726
34727   arg1 = (Dali::Actor *)jarg1;
34728   arg2 = (Dali::Vector3 *)jarg2;
34729   if (!arg2) {
34730     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34731     return ;
34732   }
34733   {
34734     try {
34735       (arg1)->TranslateBy((Dali::Vector3 const &)*arg2);
34736     } catch (std::out_of_range& e) {
34737       {
34738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34739       };
34740     } catch (std::exception& e) {
34741       {
34742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34743       };
34744     } catch (Dali::DaliException e) {
34745       {
34746         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34747       };
34748     } catch (...) {
34749       {
34750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34751       };
34752     }
34753   }
34754
34755 }
34756
34757
34758 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentPosition(void * jarg1) {
34759   void * jresult ;
34760   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34761   Dali::Vector3 result;
34762
34763   arg1 = (Dali::Actor *)jarg1;
34764   {
34765     try {
34766       result = ((Dali::Actor const *)arg1)->GetCurrentPosition();
34767     } catch (std::out_of_range& e) {
34768       {
34769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34770       };
34771     } catch (std::exception& e) {
34772       {
34773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34774       };
34775     } catch (Dali::DaliException e) {
34776       {
34777         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34778       };
34779     } catch (...) {
34780       {
34781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34782       };
34783     }
34784   }
34785
34786   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34787   return jresult;
34788 }
34789
34790
34791 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldPosition(void * jarg1) {
34792   void * jresult ;
34793   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34794   Dali::Vector3 result;
34795
34796   arg1 = (Dali::Actor *)jarg1;
34797   {
34798     try {
34799       result = ((Dali::Actor const *)arg1)->GetCurrentWorldPosition();
34800     } catch (std::out_of_range& e) {
34801       {
34802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34803       };
34804     } catch (std::exception& e) {
34805       {
34806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34807       };
34808     } catch (Dali::DaliException e) {
34809       {
34810         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34811       };
34812     } catch (...) {
34813       {
34814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34815       };
34816     }
34817   }
34818
34819   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34820   return jresult;
34821 }
34822
34823
34824 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritPosition(void * jarg1, unsigned int jarg2) {
34825   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34826   bool arg2 ;
34827
34828   arg1 = (Dali::Actor *)jarg1;
34829   arg2 = jarg2 ? true : false;
34830   {
34831     try {
34832       (arg1)->SetInheritPosition(arg2);
34833     } catch (std::out_of_range& e) {
34834       {
34835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34836       };
34837     } catch (std::exception& e) {
34838       {
34839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34840       };
34841     } catch (Dali::DaliException e) {
34842       {
34843         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34844       };
34845     } catch (...) {
34846       {
34847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34848       };
34849     }
34850   }
34851
34852 }
34853
34854
34855 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsPositionInherited(void * jarg1) {
34856   unsigned int jresult ;
34857   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34858   bool result;
34859
34860   arg1 = (Dali::Actor *)jarg1;
34861   {
34862     try {
34863       result = (bool)((Dali::Actor const *)arg1)->IsPositionInherited();
34864     } catch (std::out_of_range& e) {
34865       {
34866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34867       };
34868     } catch (std::exception& e) {
34869       {
34870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34871       };
34872     } catch (Dali::DaliException e) {
34873       {
34874         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34875       };
34876     } catch (...) {
34877       {
34878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34879       };
34880     }
34881   }
34882
34883   jresult = result;
34884   return jresult;
34885 }
34886
34887
34888 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
34889   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34890   Dali::Degree *arg2 = 0 ;
34891   Dali::Vector3 *arg3 = 0 ;
34892
34893   arg1 = (Dali::Actor *)jarg1;
34894   arg2 = (Dali::Degree *)jarg2;
34895   if (!arg2) {
34896     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
34897     return ;
34898   }
34899   arg3 = (Dali::Vector3 *)jarg3;
34900   if (!arg3) {
34901     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34902     return ;
34903   }
34904   {
34905     try {
34906       (arg1)->SetOrientation((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
34907     } catch (std::out_of_range& e) {
34908       {
34909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34910       };
34911     } catch (std::exception& e) {
34912       {
34913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34914       };
34915     } catch (Dali::DaliException e) {
34916       {
34917         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34918       };
34919     } catch (...) {
34920       {
34921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34922       };
34923     }
34924   }
34925
34926 }
34927
34928
34929 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
34930   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34931   Dali::Radian *arg2 = 0 ;
34932   Dali::Vector3 *arg3 = 0 ;
34933
34934   arg1 = (Dali::Actor *)jarg1;
34935   arg2 = (Dali::Radian *)jarg2;
34936   if (!arg2) {
34937     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
34938     return ;
34939   }
34940   arg3 = (Dali::Vector3 *)jarg3;
34941   if (!arg3) {
34942     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34943     return ;
34944   }
34945   {
34946     try {
34947       (arg1)->SetOrientation((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
34948     } catch (std::out_of_range& e) {
34949       {
34950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34951       };
34952     } catch (std::exception& e) {
34953       {
34954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34955       };
34956     } catch (Dali::DaliException e) {
34957       {
34958         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34959       };
34960     } catch (...) {
34961       {
34962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34963       };
34964     }
34965   }
34966
34967 }
34968
34969
34970 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_2(void * jarg1, void * jarg2) {
34971   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34972   Dali::Quaternion *arg2 = 0 ;
34973
34974   arg1 = (Dali::Actor *)jarg1;
34975   arg2 = (Dali::Quaternion *)jarg2;
34976   if (!arg2) {
34977     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
34978     return ;
34979   }
34980   {
34981     try {
34982       (arg1)->SetOrientation((Dali::Quaternion const &)*arg2);
34983     } catch (std::out_of_range& e) {
34984       {
34985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34986       };
34987     } catch (std::exception& e) {
34988       {
34989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34990       };
34991     } catch (Dali::DaliException e) {
34992       {
34993         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34994       };
34995     } catch (...) {
34996       {
34997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34998       };
34999     }
35000   }
35001
35002 }
35003
35004
35005 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
35006   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35007   Dali::Degree *arg2 = 0 ;
35008   Dali::Vector3 *arg3 = 0 ;
35009
35010   arg1 = (Dali::Actor *)jarg1;
35011   arg2 = (Dali::Degree *)jarg2;
35012   if (!arg2) {
35013     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
35014     return ;
35015   }
35016   arg3 = (Dali::Vector3 *)jarg3;
35017   if (!arg3) {
35018     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35019     return ;
35020   }
35021   {
35022     try {
35023       (arg1)->RotateBy((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
35024     } catch (std::out_of_range& e) {
35025       {
35026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35027       };
35028     } catch (std::exception& e) {
35029       {
35030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35031       };
35032     } catch (Dali::DaliException e) {
35033       {
35034         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35035       };
35036     } catch (...) {
35037       {
35038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35039       };
35040     }
35041   }
35042
35043 }
35044
35045
35046 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
35047   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35048   Dali::Radian *arg2 = 0 ;
35049   Dali::Vector3 *arg3 = 0 ;
35050
35051   arg1 = (Dali::Actor *)jarg1;
35052   arg2 = (Dali::Radian *)jarg2;
35053   if (!arg2) {
35054     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
35055     return ;
35056   }
35057   arg3 = (Dali::Vector3 *)jarg3;
35058   if (!arg3) {
35059     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35060     return ;
35061   }
35062   {
35063     try {
35064       (arg1)->RotateBy((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
35065     } catch (std::out_of_range& e) {
35066       {
35067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35068       };
35069     } catch (std::exception& e) {
35070       {
35071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35072       };
35073     } catch (Dali::DaliException e) {
35074       {
35075         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35076       };
35077     } catch (...) {
35078       {
35079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35080       };
35081     }
35082   }
35083
35084 }
35085
35086
35087 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_2(void * jarg1, void * jarg2) {
35088   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35089   Dali::Quaternion *arg2 = 0 ;
35090
35091   arg1 = (Dali::Actor *)jarg1;
35092   arg2 = (Dali::Quaternion *)jarg2;
35093   if (!arg2) {
35094     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
35095     return ;
35096   }
35097   {
35098     try {
35099       (arg1)->RotateBy((Dali::Quaternion const &)*arg2);
35100     } catch (std::out_of_range& e) {
35101       {
35102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35103       };
35104     } catch (std::exception& e) {
35105       {
35106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35107       };
35108     } catch (Dali::DaliException e) {
35109       {
35110         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35111       };
35112     } catch (...) {
35113       {
35114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35115       };
35116     }
35117   }
35118
35119 }
35120
35121
35122 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOrientation(void * jarg1) {
35123   void * jresult ;
35124   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35125   Dali::Quaternion result;
35126
35127   arg1 = (Dali::Actor *)jarg1;
35128   {
35129     try {
35130       result = ((Dali::Actor const *)arg1)->GetCurrentOrientation();
35131     } catch (std::out_of_range& e) {
35132       {
35133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35134       };
35135     } catch (std::exception& e) {
35136       {
35137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35138       };
35139     } catch (Dali::DaliException e) {
35140       {
35141         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35142       };
35143     } catch (...) {
35144       {
35145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35146       };
35147     }
35148   }
35149
35150   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
35151   return jresult;
35152 }
35153
35154
35155 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritOrientation(void * jarg1, unsigned int jarg2) {
35156   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35157   bool arg2 ;
35158
35159   arg1 = (Dali::Actor *)jarg1;
35160   arg2 = jarg2 ? true : false;
35161   {
35162     try {
35163       (arg1)->SetInheritOrientation(arg2);
35164     } catch (std::out_of_range& e) {
35165       {
35166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35167       };
35168     } catch (std::exception& e) {
35169       {
35170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35171       };
35172     } catch (Dali::DaliException e) {
35173       {
35174         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35175       };
35176     } catch (...) {
35177       {
35178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35179       };
35180     }
35181   }
35182
35183 }
35184
35185
35186 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsOrientationInherited(void * jarg1) {
35187   unsigned int jresult ;
35188   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35189   bool result;
35190
35191   arg1 = (Dali::Actor *)jarg1;
35192   {
35193     try {
35194       result = (bool)((Dali::Actor const *)arg1)->IsOrientationInherited();
35195     } catch (std::out_of_range& e) {
35196       {
35197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35198       };
35199     } catch (std::exception& e) {
35200       {
35201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35202       };
35203     } catch (Dali::DaliException e) {
35204       {
35205         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35206       };
35207     } catch (...) {
35208       {
35209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35210       };
35211     }
35212   }
35213
35214   jresult = result;
35215   return jresult;
35216 }
35217
35218
35219 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldOrientation(void * jarg1) {
35220   void * jresult ;
35221   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35222   Dali::Quaternion result;
35223
35224   arg1 = (Dali::Actor *)jarg1;
35225   {
35226     try {
35227       result = ((Dali::Actor const *)arg1)->GetCurrentWorldOrientation();
35228     } catch (std::out_of_range& e) {
35229       {
35230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35231       };
35232     } catch (std::exception& e) {
35233       {
35234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35235       };
35236     } catch (Dali::DaliException e) {
35237       {
35238         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35239       };
35240     } catch (...) {
35241       {
35242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35243       };
35244     }
35245   }
35246
35247   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
35248   return jresult;
35249 }
35250
35251
35252 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_0(void * jarg1, float jarg2) {
35253   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35254   float arg2 ;
35255
35256   arg1 = (Dali::Actor *)jarg1;
35257   arg2 = (float)jarg2;
35258   {
35259     try {
35260       (arg1)->SetScale(arg2);
35261     } catch (std::out_of_range& e) {
35262       {
35263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35264       };
35265     } catch (std::exception& e) {
35266       {
35267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35268       };
35269     } catch (Dali::DaliException e) {
35270       {
35271         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35272       };
35273     } catch (...) {
35274       {
35275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35276       };
35277     }
35278   }
35279
35280 }
35281
35282
35283 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
35284   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35285   float arg2 ;
35286   float arg3 ;
35287   float arg4 ;
35288
35289   arg1 = (Dali::Actor *)jarg1;
35290   arg2 = (float)jarg2;
35291   arg3 = (float)jarg3;
35292   arg4 = (float)jarg4;
35293   {
35294     try {
35295       (arg1)->SetScale(arg2,arg3,arg4);
35296     } catch (std::out_of_range& e) {
35297       {
35298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35299       };
35300     } catch (std::exception& e) {
35301       {
35302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35303       };
35304     } catch (Dali::DaliException e) {
35305       {
35306         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35307       };
35308     } catch (...) {
35309       {
35310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35311       };
35312     }
35313   }
35314
35315 }
35316
35317
35318 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_2(void * jarg1, void * jarg2) {
35319   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35320   Dali::Vector3 *arg2 = 0 ;
35321
35322   arg1 = (Dali::Actor *)jarg1;
35323   arg2 = (Dali::Vector3 *)jarg2;
35324   if (!arg2) {
35325     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35326     return ;
35327   }
35328   {
35329     try {
35330       (arg1)->SetScale((Dali::Vector3 const &)*arg2);
35331     } catch (std::out_of_range& e) {
35332       {
35333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35334       };
35335     } catch (std::exception& e) {
35336       {
35337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35338       };
35339     } catch (Dali::DaliException e) {
35340       {
35341         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35342       };
35343     } catch (...) {
35344       {
35345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35346       };
35347     }
35348   }
35349
35350 }
35351
35352
35353 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_ScaleBy(void * jarg1, void * jarg2) {
35354   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35355   Dali::Vector3 *arg2 = 0 ;
35356
35357   arg1 = (Dali::Actor *)jarg1;
35358   arg2 = (Dali::Vector3 *)jarg2;
35359   if (!arg2) {
35360     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35361     return ;
35362   }
35363   {
35364     try {
35365       (arg1)->ScaleBy((Dali::Vector3 const &)*arg2);
35366     } catch (std::out_of_range& e) {
35367       {
35368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35369       };
35370     } catch (std::exception& e) {
35371       {
35372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35373       };
35374     } catch (Dali::DaliException e) {
35375       {
35376         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35377       };
35378     } catch (...) {
35379       {
35380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35381       };
35382     }
35383   }
35384
35385 }
35386
35387
35388 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentScale(void * jarg1) {
35389   void * jresult ;
35390   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35391   Dali::Vector3 result;
35392
35393   arg1 = (Dali::Actor *)jarg1;
35394   {
35395     try {
35396       result = ((Dali::Actor const *)arg1)->GetCurrentScale();
35397     } catch (std::out_of_range& e) {
35398       {
35399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35400       };
35401     } catch (std::exception& e) {
35402       {
35403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35404       };
35405     } catch (Dali::DaliException e) {
35406       {
35407         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35408       };
35409     } catch (...) {
35410       {
35411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35412       };
35413     }
35414   }
35415
35416   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
35417   return jresult;
35418 }
35419
35420
35421 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldScale(void * jarg1) {
35422   void * jresult ;
35423   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35424   Dali::Vector3 result;
35425
35426   arg1 = (Dali::Actor *)jarg1;
35427   {
35428     try {
35429       result = ((Dali::Actor const *)arg1)->GetCurrentWorldScale();
35430     } catch (std::out_of_range& e) {
35431       {
35432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35433       };
35434     } catch (std::exception& e) {
35435       {
35436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35437       };
35438     } catch (Dali::DaliException e) {
35439       {
35440         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35441       };
35442     } catch (...) {
35443       {
35444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35445       };
35446     }
35447   }
35448
35449   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
35450   return jresult;
35451 }
35452
35453
35454 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritScale(void * jarg1, unsigned int jarg2) {
35455   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35456   bool arg2 ;
35457
35458   arg1 = (Dali::Actor *)jarg1;
35459   arg2 = jarg2 ? true : false;
35460   {
35461     try {
35462       (arg1)->SetInheritScale(arg2);
35463     } catch (std::out_of_range& e) {
35464       {
35465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35466       };
35467     } catch (std::exception& e) {
35468       {
35469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35470       };
35471     } catch (Dali::DaliException e) {
35472       {
35473         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35474       };
35475     } catch (...) {
35476       {
35477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35478       };
35479     }
35480   }
35481
35482 }
35483
35484
35485 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsScaleInherited(void * jarg1) {
35486   unsigned int jresult ;
35487   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35488   bool result;
35489
35490   arg1 = (Dali::Actor *)jarg1;
35491   {
35492     try {
35493       result = (bool)((Dali::Actor const *)arg1)->IsScaleInherited();
35494     } catch (std::out_of_range& e) {
35495       {
35496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35497       };
35498     } catch (std::exception& e) {
35499       {
35500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35501       };
35502     } catch (Dali::DaliException e) {
35503       {
35504         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35505       };
35506     } catch (...) {
35507       {
35508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35509       };
35510     }
35511   }
35512
35513   jresult = result;
35514   return jresult;
35515 }
35516
35517
35518 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldMatrix(void * jarg1) {
35519   void * jresult ;
35520   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35521   Dali::Matrix result;
35522
35523   arg1 = (Dali::Actor *)jarg1;
35524   {
35525     try {
35526       result = ((Dali::Actor const *)arg1)->GetCurrentWorldMatrix();
35527     } catch (std::out_of_range& e) {
35528       {
35529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35530       };
35531     } catch (std::exception& e) {
35532       {
35533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35534       };
35535     } catch (Dali::DaliException e) {
35536       {
35537         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35538       };
35539     } catch (...) {
35540       {
35541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35542       };
35543     }
35544   }
35545
35546   jresult = new Dali::Matrix((const Dali::Matrix &)result);
35547   return jresult;
35548 }
35549
35550
35551 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetVisible(void * jarg1, unsigned int jarg2) {
35552   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35553   bool arg2 ;
35554
35555   arg1 = (Dali::Actor *)jarg1;
35556   arg2 = jarg2 ? true : false;
35557   {
35558     try {
35559       (arg1)->SetVisible(arg2);
35560     } catch (std::out_of_range& e) {
35561       {
35562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35563       };
35564     } catch (std::exception& e) {
35565       {
35566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35567       };
35568     } catch (Dali::DaliException e) {
35569       {
35570         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35571       };
35572     } catch (...) {
35573       {
35574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35575       };
35576     }
35577   }
35578
35579 }
35580
35581
35582 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsVisible(void * jarg1) {
35583   unsigned int jresult ;
35584   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35585   bool result;
35586
35587   arg1 = (Dali::Actor *)jarg1;
35588   {
35589     try {
35590       result = (bool)((Dali::Actor const *)arg1)->IsVisible();
35591     } catch (std::out_of_range& e) {
35592       {
35593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35594       };
35595     } catch (std::exception& e) {
35596       {
35597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35598       };
35599     } catch (Dali::DaliException e) {
35600       {
35601         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35602       };
35603     } catch (...) {
35604       {
35605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35606       };
35607     }
35608   }
35609
35610   jresult = result;
35611   return jresult;
35612 }
35613
35614
35615 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOpacity(void * jarg1, float jarg2) {
35616   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35617   float arg2 ;
35618
35619   arg1 = (Dali::Actor *)jarg1;
35620   arg2 = (float)jarg2;
35621   {
35622     try {
35623       (arg1)->SetOpacity(arg2);
35624     } catch (std::out_of_range& e) {
35625       {
35626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35627       };
35628     } catch (std::exception& e) {
35629       {
35630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35631       };
35632     } catch (Dali::DaliException e) {
35633       {
35634         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35635       };
35636     } catch (...) {
35637       {
35638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35639       };
35640     }
35641   }
35642
35643 }
35644
35645
35646 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOpacity(void * jarg1) {
35647   float jresult ;
35648   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35649   float result;
35650
35651   arg1 = (Dali::Actor *)jarg1;
35652   {
35653     try {
35654       result = (float)((Dali::Actor const *)arg1)->GetCurrentOpacity();
35655     } catch (std::out_of_range& e) {
35656       {
35657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35658       };
35659     } catch (std::exception& e) {
35660       {
35661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35662       };
35663     } catch (Dali::DaliException e) {
35664       {
35665         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35666       };
35667     } catch (...) {
35668       {
35669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35670       };
35671     }
35672   }
35673
35674   jresult = result;
35675   return jresult;
35676 }
35677
35678
35679 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColor(void * jarg1, void * jarg2) {
35680   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35681   Dali::Vector4 *arg2 = 0 ;
35682
35683   arg1 = (Dali::Actor *)jarg1;
35684   arg2 = (Dali::Vector4 *)jarg2;
35685   if (!arg2) {
35686     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
35687     return ;
35688   }
35689   {
35690     try {
35691       (arg1)->SetColor((Dali::Vector4 const &)*arg2);
35692     } catch (std::out_of_range& e) {
35693       {
35694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35695       };
35696     } catch (std::exception& e) {
35697       {
35698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35699       };
35700     } catch (Dali::DaliException e) {
35701       {
35702         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35703       };
35704     } catch (...) {
35705       {
35706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35707       };
35708     }
35709   }
35710
35711 }
35712
35713
35714 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentColor(void * jarg1) {
35715   void * jresult ;
35716   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35717   Dali::Vector4 result;
35718
35719   arg1 = (Dali::Actor *)jarg1;
35720   {
35721     try {
35722       result = ((Dali::Actor const *)arg1)->GetCurrentColor();
35723     } catch (std::out_of_range& e) {
35724       {
35725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35726       };
35727     } catch (std::exception& e) {
35728       {
35729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35730       };
35731     } catch (Dali::DaliException e) {
35732       {
35733         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35734       };
35735     } catch (...) {
35736       {
35737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35738       };
35739     }
35740   }
35741
35742   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
35743   return jresult;
35744 }
35745
35746
35747 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColorMode(void * jarg1, int jarg2) {
35748   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35749   Dali::ColorMode arg2 ;
35750
35751   arg1 = (Dali::Actor *)jarg1;
35752   arg2 = (Dali::ColorMode)jarg2;
35753   {
35754     try {
35755       (arg1)->SetColorMode(arg2);
35756     } catch (std::out_of_range& e) {
35757       {
35758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35759       };
35760     } catch (std::exception& e) {
35761       {
35762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35763       };
35764     } catch (Dali::DaliException e) {
35765       {
35766         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35767       };
35768     } catch (...) {
35769       {
35770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35771       };
35772     }
35773   }
35774
35775 }
35776
35777
35778 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetColorMode(void * jarg1) {
35779   int jresult ;
35780   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35781   Dali::ColorMode result;
35782
35783   arg1 = (Dali::Actor *)jarg1;
35784   {
35785     try {
35786       result = (Dali::ColorMode)((Dali::Actor const *)arg1)->GetColorMode();
35787     } catch (std::out_of_range& e) {
35788       {
35789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35790       };
35791     } catch (std::exception& e) {
35792       {
35793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35794       };
35795     } catch (Dali::DaliException e) {
35796       {
35797         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35798       };
35799     } catch (...) {
35800       {
35801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35802       };
35803     }
35804   }
35805
35806   jresult = (int)result;
35807   return jresult;
35808 }
35809
35810
35811 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldColor(void * jarg1) {
35812   void * jresult ;
35813   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35814   Dali::Vector4 result;
35815
35816   arg1 = (Dali::Actor *)jarg1;
35817   {
35818     try {
35819       result = ((Dali::Actor const *)arg1)->GetCurrentWorldColor();
35820     } catch (std::out_of_range& e) {
35821       {
35822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35823       };
35824     } catch (std::exception& e) {
35825       {
35826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35827       };
35828     } catch (Dali::DaliException e) {
35829       {
35830         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35831       };
35832     } catch (...) {
35833       {
35834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35835       };
35836     }
35837   }
35838
35839   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
35840   return jresult;
35841 }
35842
35843
35844 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetDrawMode(void * jarg1, int jarg2) {
35845   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35846   Dali::DrawMode::Type arg2 ;
35847
35848   arg1 = (Dali::Actor *)jarg1;
35849   arg2 = (Dali::DrawMode::Type)jarg2;
35850   {
35851     try {
35852       (arg1)->SetDrawMode(arg2);
35853     } catch (std::out_of_range& e) {
35854       {
35855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35856       };
35857     } catch (std::exception& e) {
35858       {
35859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35860       };
35861     } catch (Dali::DaliException e) {
35862       {
35863         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35864       };
35865     } catch (...) {
35866       {
35867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35868       };
35869     }
35870   }
35871
35872 }
35873
35874
35875 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetDrawMode(void * jarg1) {
35876   int jresult ;
35877   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35878   Dali::DrawMode::Type result;
35879
35880   arg1 = (Dali::Actor *)jarg1;
35881   {
35882     try {
35883       result = (Dali::DrawMode::Type)((Dali::Actor const *)arg1)->GetDrawMode();
35884     } catch (std::out_of_range& e) {
35885       {
35886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35887       };
35888     } catch (std::exception& e) {
35889       {
35890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35891       };
35892     } catch (Dali::DaliException e) {
35893       {
35894         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35895       };
35896     } catch (...) {
35897       {
35898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35899       };
35900     }
35901   }
35902
35903   jresult = (int)result;
35904   return jresult;
35905 }
35906
35907
35908 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSensitive(void * jarg1, unsigned int jarg2) {
35909   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35910   bool arg2 ;
35911
35912   arg1 = (Dali::Actor *)jarg1;
35913   arg2 = jarg2 ? true : false;
35914   {
35915     try {
35916       (arg1)->SetSensitive(arg2);
35917     } catch (std::out_of_range& e) {
35918       {
35919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35920       };
35921     } catch (std::exception& e) {
35922       {
35923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35924       };
35925     } catch (Dali::DaliException e) {
35926       {
35927         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35928       };
35929     } catch (...) {
35930       {
35931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35932       };
35933     }
35934   }
35935
35936 }
35937
35938
35939 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsSensitive(void * jarg1) {
35940   unsigned int jresult ;
35941   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35942   bool result;
35943
35944   arg1 = (Dali::Actor *)jarg1;
35945   {
35946     try {
35947       result = (bool)((Dali::Actor const *)arg1)->IsSensitive();
35948     } catch (std::out_of_range& e) {
35949       {
35950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35951       };
35952     } catch (std::exception& e) {
35953       {
35954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35955       };
35956     } catch (Dali::DaliException e) {
35957       {
35958         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35959       };
35960     } catch (...) {
35961       {
35962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35963       };
35964     }
35965   }
35966
35967   jresult = result;
35968   return jresult;
35969 }
35970
35971
35972 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_ScreenToLocal(void * jarg1, float * jarg2, float * jarg3, float jarg4, float jarg5) {
35973   unsigned int jresult ;
35974   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35975   float *arg2 = 0 ;
35976   float *arg3 = 0 ;
35977   float arg4 ;
35978   float arg5 ;
35979   bool result;
35980
35981   arg1 = (Dali::Actor *)jarg1;
35982   arg2 = (float *)jarg2;
35983   arg3 = (float *)jarg3;
35984   arg4 = (float)jarg4;
35985   arg5 = (float)jarg5;
35986   {
35987     try {
35988       result = (bool)((Dali::Actor const *)arg1)->ScreenToLocal(*arg2,*arg3,arg4,arg5);
35989     } catch (std::out_of_range& e) {
35990       {
35991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35992       };
35993     } catch (std::exception& e) {
35994       {
35995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35996       };
35997     } catch (Dali::DaliException e) {
35998       {
35999         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36000       };
36001     } catch (...) {
36002       {
36003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36004       };
36005     }
36006   }
36007
36008   jresult = result;
36009   return jresult;
36010 }
36011
36012
36013 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetLeaveRequired(void * jarg1, unsigned int jarg2) {
36014   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36015   bool arg2 ;
36016
36017   arg1 = (Dali::Actor *)jarg1;
36018   arg2 = jarg2 ? true : false;
36019   {
36020     try {
36021       (arg1)->SetLeaveRequired(arg2);
36022     } catch (std::out_of_range& e) {
36023       {
36024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36025       };
36026     } catch (std::exception& e) {
36027       {
36028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36029       };
36030     } catch (Dali::DaliException e) {
36031       {
36032         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36033       };
36034     } catch (...) {
36035       {
36036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36037       };
36038     }
36039   }
36040
36041 }
36042
36043
36044 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetLeaveRequired(void * jarg1) {
36045   unsigned int jresult ;
36046   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36047   bool result;
36048
36049   arg1 = (Dali::Actor *)jarg1;
36050   {
36051     try {
36052       result = (bool)((Dali::Actor const *)arg1)->GetLeaveRequired();
36053     } catch (std::out_of_range& e) {
36054       {
36055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36056       };
36057     } catch (std::exception& e) {
36058       {
36059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36060       };
36061     } catch (Dali::DaliException e) {
36062       {
36063         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36064       };
36065     } catch (...) {
36066       {
36067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36068       };
36069     }
36070   }
36071
36072   jresult = result;
36073   return jresult;
36074 }
36075
36076
36077 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetKeyboardFocusable(void * jarg1, unsigned int jarg2) {
36078   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36079   bool arg2 ;
36080
36081   arg1 = (Dali::Actor *)jarg1;
36082   arg2 = jarg2 ? true : false;
36083   {
36084     try {
36085       (arg1)->SetKeyboardFocusable(arg2);
36086     } catch (std::out_of_range& e) {
36087       {
36088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36089       };
36090     } catch (std::exception& e) {
36091       {
36092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36093       };
36094     } catch (Dali::DaliException e) {
36095       {
36096         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36097       };
36098     } catch (...) {
36099       {
36100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36101       };
36102     }
36103   }
36104
36105 }
36106
36107
36108 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsKeyboardFocusable(void * jarg1) {
36109   unsigned int jresult ;
36110   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36111   bool result;
36112
36113   arg1 = (Dali::Actor *)jarg1;
36114   {
36115     try {
36116       result = (bool)((Dali::Actor const *)arg1)->IsKeyboardFocusable();
36117     } catch (std::out_of_range& e) {
36118       {
36119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36120       };
36121     } catch (std::exception& e) {
36122       {
36123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36124       };
36125     } catch (Dali::DaliException e) {
36126       {
36127         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36128       };
36129     } catch (...) {
36130       {
36131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36132       };
36133     }
36134   }
36135
36136   jresult = result;
36137   return jresult;
36138 }
36139
36140
36141 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetResizePolicy(void * jarg1, int jarg2, int jarg3) {
36142   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36143   Dali::ResizePolicy::Type arg2 ;
36144   Dali::Dimension::Type arg3 ;
36145
36146   arg1 = (Dali::Actor *)jarg1;
36147   arg2 = (Dali::ResizePolicy::Type)jarg2;
36148   arg3 = (Dali::Dimension::Type)jarg3;
36149   {
36150     try {
36151       (arg1)->SetResizePolicy(arg2,arg3);
36152     } catch (std::out_of_range& e) {
36153       {
36154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36155       };
36156     } catch (std::exception& e) {
36157       {
36158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36159       };
36160     } catch (Dali::DaliException e) {
36161       {
36162         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36163       };
36164     } catch (...) {
36165       {
36166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36167       };
36168     }
36169   }
36170
36171 }
36172
36173
36174 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetResizePolicy(void * jarg1, int jarg2) {
36175   int jresult ;
36176   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36177   Dali::Dimension::Type arg2 ;
36178   Dali::ResizePolicy::Type result;
36179
36180   arg1 = (Dali::Actor *)jarg1;
36181   arg2 = (Dali::Dimension::Type)jarg2;
36182   {
36183     try {
36184       result = (Dali::ResizePolicy::Type)((Dali::Actor const *)arg1)->GetResizePolicy(arg2);
36185     } catch (std::out_of_range& e) {
36186       {
36187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36188       };
36189     } catch (std::exception& e) {
36190       {
36191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36192       };
36193     } catch (Dali::DaliException e) {
36194       {
36195         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36196       };
36197     } catch (...) {
36198       {
36199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36200       };
36201     }
36202   }
36203
36204   jresult = (int)result;
36205   return jresult;
36206 }
36207
36208
36209 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeScalePolicy(void * jarg1, int jarg2) {
36210   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36211   Dali::SizeScalePolicy::Type arg2 ;
36212
36213   arg1 = (Dali::Actor *)jarg1;
36214   arg2 = (Dali::SizeScalePolicy::Type)jarg2;
36215   {
36216     try {
36217       (arg1)->SetSizeScalePolicy(arg2);
36218     } catch (std::out_of_range& e) {
36219       {
36220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36221       };
36222     } catch (std::exception& e) {
36223       {
36224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36225       };
36226     } catch (Dali::DaliException e) {
36227       {
36228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36229       };
36230     } catch (...) {
36231       {
36232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36233       };
36234     }
36235   }
36236
36237 }
36238
36239
36240 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetSizeScalePolicy(void * jarg1) {
36241   int jresult ;
36242   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36243   Dali::SizeScalePolicy::Type result;
36244
36245   arg1 = (Dali::Actor *)jarg1;
36246   {
36247     try {
36248       result = (Dali::SizeScalePolicy::Type)((Dali::Actor const *)arg1)->GetSizeScalePolicy();
36249     } catch (std::out_of_range& e) {
36250       {
36251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36252       };
36253     } catch (std::exception& e) {
36254       {
36255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36256       };
36257     } catch (Dali::DaliException e) {
36258       {
36259         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36260       };
36261     } catch (...) {
36262       {
36263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36264       };
36265     }
36266   }
36267
36268   jresult = (int)result;
36269   return jresult;
36270 }
36271
36272
36273 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeModeFactor(void * jarg1, void * jarg2) {
36274   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36275   Dali::Vector3 *arg2 = 0 ;
36276
36277   arg1 = (Dali::Actor *)jarg1;
36278   arg2 = (Dali::Vector3 *)jarg2;
36279   if (!arg2) {
36280     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
36281     return ;
36282   }
36283   {
36284     try {
36285       (arg1)->SetSizeModeFactor((Dali::Vector3 const &)*arg2);
36286     } catch (std::out_of_range& e) {
36287       {
36288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36289       };
36290     } catch (std::exception& e) {
36291       {
36292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36293       };
36294     } catch (Dali::DaliException e) {
36295       {
36296         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36297       };
36298     } catch (...) {
36299       {
36300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36301       };
36302     }
36303   }
36304
36305 }
36306
36307
36308 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetSizeModeFactor(void * jarg1) {
36309   void * jresult ;
36310   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36311   Dali::Vector3 result;
36312
36313   arg1 = (Dali::Actor *)jarg1;
36314   {
36315     try {
36316       result = ((Dali::Actor const *)arg1)->GetSizeModeFactor();
36317     } catch (std::out_of_range& e) {
36318       {
36319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36320       };
36321     } catch (std::exception& e) {
36322       {
36323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36324       };
36325     } catch (Dali::DaliException e) {
36326       {
36327         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36328       };
36329     } catch (...) {
36330       {
36331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36332       };
36333     }
36334   }
36335
36336   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
36337   return jresult;
36338 }
36339
36340
36341 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetHeightForWidth(void * jarg1, float jarg2) {
36342   float jresult ;
36343   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36344   float arg2 ;
36345   float result;
36346
36347   arg1 = (Dali::Actor *)jarg1;
36348   arg2 = (float)jarg2;
36349   {
36350     try {
36351       result = (float)(arg1)->GetHeightForWidth(arg2);
36352     } catch (std::out_of_range& e) {
36353       {
36354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36355       };
36356     } catch (std::exception& e) {
36357       {
36358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36359       };
36360     } catch (Dali::DaliException e) {
36361       {
36362         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36363       };
36364     } catch (...) {
36365       {
36366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36367       };
36368     }
36369   }
36370
36371   jresult = result;
36372   return jresult;
36373 }
36374
36375
36376 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetWidthForHeight(void * jarg1, float jarg2) {
36377   float jresult ;
36378   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36379   float arg2 ;
36380   float result;
36381
36382   arg1 = (Dali::Actor *)jarg1;
36383   arg2 = (float)jarg2;
36384   {
36385     try {
36386       result = (float)(arg1)->GetWidthForHeight(arg2);
36387     } catch (std::out_of_range& e) {
36388       {
36389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36390       };
36391     } catch (std::exception& e) {
36392       {
36393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36394       };
36395     } catch (Dali::DaliException e) {
36396       {
36397         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36398       };
36399     } catch (...) {
36400       {
36401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36402       };
36403     }
36404   }
36405
36406   jresult = result;
36407   return jresult;
36408 }
36409
36410
36411 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetRelayoutSize(void * jarg1, int jarg2) {
36412   float jresult ;
36413   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36414   Dali::Dimension::Type arg2 ;
36415   float result;
36416
36417   arg1 = (Dali::Actor *)jarg1;
36418   arg2 = (Dali::Dimension::Type)jarg2;
36419   {
36420     try {
36421       result = (float)((Dali::Actor const *)arg1)->GetRelayoutSize(arg2);
36422     } catch (std::out_of_range& e) {
36423       {
36424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36425       };
36426     } catch (std::exception& e) {
36427       {
36428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36429       };
36430     } catch (Dali::DaliException e) {
36431       {
36432         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36433       };
36434     } catch (...) {
36435       {
36436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36437       };
36438     }
36439   }
36440
36441   jresult = result;
36442   return jresult;
36443 }
36444
36445
36446 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPadding(void * jarg1, void * jarg2) {
36447   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36448   Dali::Padding *arg2 = 0 ;
36449
36450   arg1 = (Dali::Actor *)jarg1;
36451   arg2 = (Dali::Padding *)jarg2;
36452   if (!arg2) {
36453     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding const & type is null", 0);
36454     return ;
36455   }
36456   {
36457     try {
36458       (arg1)->SetPadding((Dali::Padding const &)*arg2);
36459     } catch (std::out_of_range& e) {
36460       {
36461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36462       };
36463     } catch (std::exception& e) {
36464       {
36465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36466       };
36467     } catch (Dali::DaliException e) {
36468       {
36469         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36470       };
36471     } catch (...) {
36472       {
36473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36474       };
36475     }
36476   }
36477
36478 }
36479
36480
36481 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_GetPadding(void * jarg1, void * jarg2) {
36482   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36483   Dali::Padding *arg2 = 0 ;
36484
36485   arg1 = (Dali::Actor *)jarg1;
36486   arg2 = (Dali::Padding *)jarg2;
36487   if (!arg2) {
36488     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding & type is null", 0);
36489     return ;
36490   }
36491   {
36492     try {
36493       ((Dali::Actor const *)arg1)->GetPadding(*arg2);
36494     } catch (std::out_of_range& e) {
36495       {
36496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36497       };
36498     } catch (std::exception& e) {
36499       {
36500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36501       };
36502     } catch (Dali::DaliException e) {
36503       {
36504         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36505       };
36506     } catch (...) {
36507       {
36508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36509       };
36510     }
36511   }
36512
36513 }
36514
36515
36516 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMinimumSize(void * jarg1, void * jarg2) {
36517   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36518   Dali::Vector2 *arg2 = 0 ;
36519
36520   arg1 = (Dali::Actor *)jarg1;
36521   arg2 = (Dali::Vector2 *)jarg2;
36522   if (!arg2) {
36523     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
36524     return ;
36525   }
36526   {
36527     try {
36528       (arg1)->SetMinimumSize((Dali::Vector2 const &)*arg2);
36529     } catch (std::out_of_range& e) {
36530       {
36531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36532       };
36533     } catch (std::exception& e) {
36534       {
36535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36536       };
36537     } catch (Dali::DaliException e) {
36538       {
36539         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36540       };
36541     } catch (...) {
36542       {
36543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36544       };
36545     }
36546   }
36547
36548 }
36549
36550
36551 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMinimumSize(void * jarg1) {
36552   void * jresult ;
36553   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36554   Dali::Vector2 result;
36555
36556   arg1 = (Dali::Actor *)jarg1;
36557   {
36558     try {
36559       result = (arg1)->GetMinimumSize();
36560     } catch (std::out_of_range& e) {
36561       {
36562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36563       };
36564     } catch (std::exception& e) {
36565       {
36566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36567       };
36568     } catch (Dali::DaliException e) {
36569       {
36570         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36571       };
36572     } catch (...) {
36573       {
36574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36575       };
36576     }
36577   }
36578
36579   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
36580   return jresult;
36581 }
36582
36583
36584 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMaximumSize(void * jarg1, void * jarg2) {
36585   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36586   Dali::Vector2 *arg2 = 0 ;
36587
36588   arg1 = (Dali::Actor *)jarg1;
36589   arg2 = (Dali::Vector2 *)jarg2;
36590   if (!arg2) {
36591     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
36592     return ;
36593   }
36594   {
36595     try {
36596       (arg1)->SetMaximumSize((Dali::Vector2 const &)*arg2);
36597     } catch (std::out_of_range& e) {
36598       {
36599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36600       };
36601     } catch (std::exception& e) {
36602       {
36603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36604       };
36605     } catch (Dali::DaliException e) {
36606       {
36607         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36608       };
36609     } catch (...) {
36610       {
36611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36612       };
36613     }
36614   }
36615
36616 }
36617
36618
36619 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMaximumSize(void * jarg1) {
36620   void * jresult ;
36621   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36622   Dali::Vector2 result;
36623
36624   arg1 = (Dali::Actor *)jarg1;
36625   {
36626     try {
36627       result = (arg1)->GetMaximumSize();
36628     } catch (std::out_of_range& e) {
36629       {
36630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36631       };
36632     } catch (std::exception& e) {
36633       {
36634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36635       };
36636     } catch (Dali::DaliException e) {
36637       {
36638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36639       };
36640     } catch (...) {
36641       {
36642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36643       };
36644     }
36645   }
36646
36647   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
36648   return jresult;
36649 }
36650
36651
36652 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetHierarchyDepth(void * jarg1) {
36653   int jresult ;
36654   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36655   int result;
36656
36657   arg1 = (Dali::Actor *)jarg1;
36658   {
36659     try {
36660       result = (int)(arg1)->GetHierarchyDepth();
36661       Dali::Actor parent = ((Dali::Actor const *)arg1)->GetParent();
36662     } catch (std::out_of_range& e) {
36663       {
36664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36665       };
36666     } catch (std::exception& e) {
36667       {
36668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36669       };
36670     } catch (Dali::DaliException e) {
36671       {
36672         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36673       };
36674     } catch (...) {
36675       {
36676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36677       };
36678     }
36679   }
36680
36681   jresult = result;
36682   return jresult;
36683 }
36684
36685
36686 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_AddRenderer(void * jarg1, void * jarg2) {
36687   unsigned int jresult ;
36688   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36689   Dali::Renderer *arg2 = 0 ;
36690   unsigned int result;
36691
36692   arg1 = (Dali::Actor *)jarg1;
36693   arg2 = (Dali::Renderer *)jarg2;
36694   if (!arg2) {
36695     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
36696     return 0;
36697   }
36698   {
36699     try {
36700       result = (unsigned int)(arg1)->AddRenderer(*arg2);
36701     } catch (std::out_of_range& e) {
36702       {
36703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36704       };
36705     } catch (std::exception& e) {
36706       {
36707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36708       };
36709     } catch (Dali::DaliException e) {
36710       {
36711         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36712       };
36713     } catch (...) {
36714       {
36715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36716       };
36717     }
36718   }
36719
36720   jresult = result;
36721   return jresult;
36722 }
36723
36724
36725 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetRendererCount(void * jarg1) {
36726   unsigned int jresult ;
36727   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36728   unsigned int result;
36729
36730   arg1 = (Dali::Actor *)jarg1;
36731   {
36732     try {
36733       result = (unsigned int)((Dali::Actor const *)arg1)->GetRendererCount();
36734     } catch (std::out_of_range& e) {
36735       {
36736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36737       };
36738     } catch (std::exception& e) {
36739       {
36740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36741       };
36742     } catch (Dali::DaliException e) {
36743       {
36744         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36745       };
36746     } catch (...) {
36747       {
36748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36749       };
36750     }
36751   }
36752
36753   jresult = result;
36754   return jresult;
36755 }
36756
36757
36758 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetRendererAt(void * jarg1, unsigned int jarg2) {
36759   void * jresult ;
36760   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36761   unsigned int arg2 ;
36762   Dali::Renderer result;
36763
36764   arg1 = (Dali::Actor *)jarg1;
36765   arg2 = (unsigned int)jarg2;
36766   {
36767     try {
36768       result = (arg1)->GetRendererAt(arg2);
36769     } catch (std::out_of_range& e) {
36770       {
36771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36772       };
36773     } catch (std::exception& e) {
36774       {
36775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36776       };
36777     } catch (Dali::DaliException e) {
36778       {
36779         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36780       };
36781     } catch (...) {
36782       {
36783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36784       };
36785     }
36786   }
36787
36788   jresult = new Dali::Renderer((const Dali::Renderer &)result);
36789   return jresult;
36790 }
36791
36792
36793 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_0(void * jarg1, void * jarg2) {
36794   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36795   Dali::Renderer *arg2 = 0 ;
36796
36797   arg1 = (Dali::Actor *)jarg1;
36798   arg2 = (Dali::Renderer *)jarg2;
36799   if (!arg2) {
36800     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
36801     return ;
36802   }
36803   {
36804     try {
36805       (arg1)->RemoveRenderer(*arg2);
36806     } catch (std::out_of_range& e) {
36807       {
36808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36809       };
36810     } catch (std::exception& e) {
36811       {
36812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36813       };
36814     } catch (Dali::DaliException e) {
36815       {
36816         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36817       };
36818     } catch (...) {
36819       {
36820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36821       };
36822     }
36823   }
36824
36825 }
36826
36827
36828 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_1(void * jarg1, unsigned int jarg2) {
36829   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36830   unsigned int arg2 ;
36831
36832   arg1 = (Dali::Actor *)jarg1;
36833   arg2 = (unsigned int)jarg2;
36834   {
36835     try {
36836       (arg1)->RemoveRenderer(arg2);
36837     } catch (std::out_of_range& e) {
36838       {
36839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36840       };
36841     } catch (std::exception& e) {
36842       {
36843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36844       };
36845     } catch (Dali::DaliException e) {
36846       {
36847         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36848       };
36849     } catch (...) {
36850       {
36851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36852       };
36853     }
36854   }
36855
36856 }
36857
36858
36859 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchedSignal(void * jarg1) {
36860   void * jresult ;
36861   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36862   Dali::Actor::TouchSignalType *result = 0 ;
36863
36864   arg1 = (Dali::Actor *)jarg1;
36865   {
36866     try {
36867       result = (Dali::Actor::TouchSignalType *) &(arg1)->TouchedSignal();
36868     } catch (std::out_of_range& e) {
36869       {
36870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36871       };
36872     } catch (std::exception& e) {
36873       {
36874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36875       };
36876     } catch (Dali::DaliException e) {
36877       {
36878         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36879       };
36880     } catch (...) {
36881       {
36882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36883       };
36884     }
36885   }
36886
36887   jresult = (void *)result;
36888   return jresult;
36889 }
36890
36891
36892 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchSignal(void * jarg1) {
36893   void * jresult ;
36894   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36895   Dali::Actor::TouchDataSignalType *result = 0 ;
36896
36897   arg1 = (Dali::Actor *)jarg1;
36898   {
36899     try {
36900       result = (Dali::Actor::TouchDataSignalType *) &(arg1)->TouchSignal();
36901     } catch (std::out_of_range& e) {
36902       {
36903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36904       };
36905     } catch (std::exception& e) {
36906       {
36907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36908       };
36909     } catch (Dali::DaliException e) {
36910       {
36911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36912       };
36913     } catch (...) {
36914       {
36915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36916       };
36917     }
36918   }
36919
36920   jresult = (void *)result;
36921   return jresult;
36922 }
36923
36924
36925 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_HoveredSignal(void * jarg1) {
36926   void * jresult ;
36927   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36928   Dali::Actor::HoverSignalType *result = 0 ;
36929
36930   arg1 = (Dali::Actor *)jarg1;
36931   {
36932     try {
36933       result = (Dali::Actor::HoverSignalType *) &(arg1)->HoveredSignal();
36934     } catch (std::out_of_range& e) {
36935       {
36936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36937       };
36938     } catch (std::exception& e) {
36939       {
36940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36941       };
36942     } catch (Dali::DaliException e) {
36943       {
36944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36945       };
36946     } catch (...) {
36947       {
36948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36949       };
36950     }
36951   }
36952
36953   jresult = (void *)result;
36954   return jresult;
36955 }
36956
36957
36958 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_WheelEventSignal(void * jarg1) {
36959   void * jresult ;
36960   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36961   Dali::Actor::WheelEventSignalType *result = 0 ;
36962
36963   arg1 = (Dali::Actor *)jarg1;
36964   {
36965     try {
36966       result = (Dali::Actor::WheelEventSignalType *) &(arg1)->WheelEventSignal();
36967     } catch (std::out_of_range& e) {
36968       {
36969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36970       };
36971     } catch (std::exception& e) {
36972       {
36973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36974       };
36975     } catch (Dali::DaliException e) {
36976       {
36977         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36978       };
36979     } catch (...) {
36980       {
36981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36982       };
36983     }
36984   }
36985
36986   jresult = (void *)result;
36987   return jresult;
36988 }
36989
36990
36991 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnStageSignal(void * jarg1) {
36992   void * jresult ;
36993   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36994   Dali::Actor::OnStageSignalType *result = 0 ;
36995
36996   arg1 = (Dali::Actor *)jarg1;
36997   {
36998     try {
36999       result = (Dali::Actor::OnStageSignalType *) &(arg1)->OnStageSignal();
37000     } catch (std::out_of_range& e) {
37001       {
37002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37003       };
37004     } catch (std::exception& e) {
37005       {
37006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37007       };
37008     } catch (Dali::DaliException e) {
37009       {
37010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37011       };
37012     } catch (...) {
37013       {
37014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37015       };
37016     }
37017   }
37018
37019   jresult = (void *)result;
37020   return jresult;
37021 }
37022
37023
37024 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OffStageSignal(void * jarg1) {
37025   void * jresult ;
37026   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37027   Dali::Actor::OffStageSignalType *result = 0 ;
37028
37029   arg1 = (Dali::Actor *)jarg1;
37030   {
37031     try {
37032       result = (Dali::Actor::OffStageSignalType *) &(arg1)->OffStageSignal();
37033     } catch (std::out_of_range& e) {
37034       {
37035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37036       };
37037     } catch (std::exception& e) {
37038       {
37039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37040       };
37041     } catch (Dali::DaliException e) {
37042       {
37043         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37044       };
37045     } catch (...) {
37046       {
37047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37048       };
37049     }
37050   }
37051
37052   jresult = (void *)result;
37053   return jresult;
37054 }
37055
37056
37057 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnRelayoutSignal(void * jarg1) {
37058   void * jresult ;
37059   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37060   Dali::Actor::OnRelayoutSignalType *result = 0 ;
37061
37062   arg1 = (Dali::Actor *)jarg1;
37063   {
37064     try {
37065       result = (Dali::Actor::OnRelayoutSignalType *) &(arg1)->OnRelayoutSignal();
37066     } catch (std::out_of_range& e) {
37067       {
37068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37069       };
37070     } catch (std::exception& e) {
37071       {
37072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37073       };
37074     } catch (Dali::DaliException e) {
37075       {
37076         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37077       };
37078     } catch (...) {
37079       {
37080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37081       };
37082     }
37083   }
37084
37085   jresult = (void *)result;
37086   return jresult;
37087 }
37088
37089
37090 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_UnparentAndReset(void * jarg1) {
37091   Dali::Actor *arg1 = 0 ;
37092
37093   arg1 = (Dali::Actor *)jarg1;
37094   if (!arg1) {
37095     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
37096     return ;
37097   }
37098   {
37099     try {
37100       Dali::UnparentAndReset(*arg1);
37101     } catch (std::out_of_range& e) {
37102       {
37103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37104       };
37105     } catch (std::exception& e) {
37106       {
37107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37108       };
37109     } catch (Dali::DaliException e) {
37110       {
37111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37112       };
37113     } catch (...) {
37114       {
37115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37116       };
37117     }
37118   }
37119
37120 }
37121
37122
37123 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_ENABLE_get() {
37124   int jresult ;
37125   int result;
37126
37127   result = (int)Dali::Layer::Property::CLIPPING_ENABLE;
37128   jresult = (int)result;
37129   return jresult;
37130 }
37131
37132
37133 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_BOX_get() {
37134   int jresult ;
37135   int result;
37136
37137   result = (int)Dali::Layer::Property::CLIPPING_BOX;
37138   jresult = (int)result;
37139   return jresult;
37140 }
37141
37142
37143 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_BEHAVIOR_get() {
37144   int jresult ;
37145   int result;
37146
37147   result = (int)Dali::Layer::Property::BEHAVIOR;
37148   jresult = (int)result;
37149   return jresult;
37150 }
37151
37152
37153 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer_Property() {
37154   void * jresult ;
37155   Dali::Layer::Property *result = 0 ;
37156
37157   {
37158     try {
37159       result = (Dali::Layer::Property *)new Dali::Layer::Property();
37160     } catch (std::out_of_range& e) {
37161       {
37162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37163       };
37164     } catch (std::exception& e) {
37165       {
37166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37167       };
37168     } catch (Dali::DaliException e) {
37169       {
37170         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37171       };
37172     } catch (...) {
37173       {
37174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37175       };
37176     }
37177   }
37178
37179   jresult = (void *)result;
37180   return jresult;
37181 }
37182
37183
37184 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer_Property(void * jarg1) {
37185   Dali::Layer::Property *arg1 = (Dali::Layer::Property *) 0 ;
37186
37187   arg1 = (Dali::Layer::Property *)jarg1;
37188   {
37189     try {
37190       delete arg1;
37191     } catch (std::out_of_range& e) {
37192       {
37193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37194       };
37195     } catch (std::exception& e) {
37196       {
37197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37198       };
37199     } catch (Dali::DaliException e) {
37200       {
37201         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37202       };
37203     } catch (...) {
37204       {
37205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37206       };
37207     }
37208   }
37209
37210 }
37211
37212
37213 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_0() {
37214   void * jresult ;
37215   Dali::Layer *result = 0 ;
37216
37217   {
37218     try {
37219       result = (Dali::Layer *)new Dali::Layer();
37220     } catch (std::out_of_range& e) {
37221       {
37222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37223       };
37224     } catch (std::exception& e) {
37225       {
37226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37227       };
37228     } catch (Dali::DaliException e) {
37229       {
37230         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37231       };
37232     } catch (...) {
37233       {
37234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37235       };
37236     }
37237   }
37238
37239   jresult = (void *)result;
37240   return jresult;
37241 }
37242
37243
37244 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_New() {
37245   void * jresult ;
37246   Dali::Layer result;
37247
37248   {
37249     try {
37250       result = Dali::Layer::New();
37251     } catch (std::out_of_range& e) {
37252       {
37253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37254       };
37255     } catch (std::exception& e) {
37256       {
37257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37258       };
37259     } catch (Dali::DaliException e) {
37260       {
37261         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37262       };
37263     } catch (...) {
37264       {
37265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37266       };
37267     }
37268   }
37269
37270   jresult = new Dali::Layer((const Dali::Layer &)result);
37271   return jresult;
37272 }
37273
37274
37275 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_DownCast(void * jarg1) {
37276   void * jresult ;
37277   Dali::BaseHandle arg1 ;
37278   Dali::BaseHandle *argp1 ;
37279   Dali::Layer result;
37280
37281   argp1 = (Dali::BaseHandle *)jarg1;
37282   if (!argp1) {
37283     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
37284     return 0;
37285   }
37286   arg1 = *argp1;
37287   {
37288     try {
37289       result = Dali::Layer::DownCast(arg1);
37290     } catch (std::out_of_range& e) {
37291       {
37292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37293       };
37294     } catch (std::exception& e) {
37295       {
37296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37297       };
37298     } catch (Dali::DaliException e) {
37299       {
37300         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37301       };
37302     } catch (...) {
37303       {
37304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37305       };
37306     }
37307   }
37308
37309   jresult = new Dali::Layer((const Dali::Layer &)result);
37310   return jresult;
37311 }
37312
37313
37314 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer(void * jarg1) {
37315   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37316
37317   arg1 = (Dali::Layer *)jarg1;
37318   {
37319     try {
37320       delete arg1;
37321     } catch (std::out_of_range& e) {
37322       {
37323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37324       };
37325     } catch (std::exception& e) {
37326       {
37327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37328       };
37329     } catch (Dali::DaliException e) {
37330       {
37331         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37332       };
37333     } catch (...) {
37334       {
37335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37336       };
37337     }
37338   }
37339
37340 }
37341
37342
37343 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_1(void * jarg1) {
37344   void * jresult ;
37345   Dali::Layer *arg1 = 0 ;
37346   Dali::Layer *result = 0 ;
37347
37348   arg1 = (Dali::Layer *)jarg1;
37349   if (!arg1) {
37350     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
37351     return 0;
37352   }
37353   {
37354     try {
37355       result = (Dali::Layer *)new Dali::Layer((Dali::Layer const &)*arg1);
37356     } catch (std::out_of_range& e) {
37357       {
37358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37359       };
37360     } catch (std::exception& e) {
37361       {
37362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37363       };
37364     } catch (Dali::DaliException e) {
37365       {
37366         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37367       };
37368     } catch (...) {
37369       {
37370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37371       };
37372     }
37373   }
37374
37375   jresult = (void *)result;
37376   return jresult;
37377 }
37378
37379
37380 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_Assign(void * jarg1, void * jarg2) {
37381   void * jresult ;
37382   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37383   Dali::Layer *arg2 = 0 ;
37384   Dali::Layer *result = 0 ;
37385
37386   arg1 = (Dali::Layer *)jarg1;
37387   arg2 = (Dali::Layer *)jarg2;
37388   if (!arg2) {
37389     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
37390     return 0;
37391   }
37392   {
37393     try {
37394       result = (Dali::Layer *) &(arg1)->operator =((Dali::Layer const &)*arg2);
37395     } catch (std::out_of_range& e) {
37396       {
37397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37398       };
37399     } catch (std::exception& e) {
37400       {
37401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37402       };
37403     } catch (Dali::DaliException e) {
37404       {
37405         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37406       };
37407     } catch (...) {
37408       {
37409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37410       };
37411     }
37412   }
37413
37414   jresult = (void *)result;
37415   return jresult;
37416 }
37417
37418
37419 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_GetDepth(void * jarg1) {
37420   unsigned int jresult ;
37421   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37422   unsigned int result;
37423
37424   arg1 = (Dali::Layer *)jarg1;
37425   {
37426     try {
37427       result = (unsigned int)((Dali::Layer const *)arg1)->GetDepth();
37428     } catch (std::out_of_range& e) {
37429       {
37430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37431       };
37432     } catch (std::exception& e) {
37433       {
37434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37435       };
37436     } catch (Dali::DaliException e) {
37437       {
37438         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37439       };
37440     } catch (...) {
37441       {
37442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37443       };
37444     }
37445   }
37446
37447   jresult = result;
37448   return jresult;
37449 }
37450
37451
37452 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Raise(void * jarg1) {
37453   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37454
37455   arg1 = (Dali::Layer *)jarg1;
37456   {
37457     try {
37458       (arg1)->Raise();
37459     } catch (std::out_of_range& e) {
37460       {
37461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37462       };
37463     } catch (std::exception& e) {
37464       {
37465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37466       };
37467     } catch (Dali::DaliException e) {
37468       {
37469         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37470       };
37471     } catch (...) {
37472       {
37473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37474       };
37475     }
37476   }
37477
37478 }
37479
37480
37481 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Lower(void * jarg1) {
37482   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37483
37484   arg1 = (Dali::Layer *)jarg1;
37485   {
37486     try {
37487       (arg1)->Lower();
37488     } catch (std::out_of_range& e) {
37489       {
37490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37491       };
37492     } catch (std::exception& e) {
37493       {
37494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37495       };
37496     } catch (Dali::DaliException e) {
37497       {
37498         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37499       };
37500     } catch (...) {
37501       {
37502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37503       };
37504     }
37505   }
37506
37507 }
37508
37509
37510 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseAbove(void * jarg1, void * jarg2) {
37511   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37512   Dali::Layer arg2 ;
37513   Dali::Layer *argp2 ;
37514
37515   arg1 = (Dali::Layer *)jarg1;
37516   argp2 = (Dali::Layer *)jarg2;
37517   if (!argp2) {
37518     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37519     return ;
37520   }
37521   arg2 = *argp2;
37522   {
37523     try {
37524       (arg1)->RaiseAbove(arg2);
37525     } catch (std::out_of_range& e) {
37526       {
37527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37528       };
37529     } catch (std::exception& e) {
37530       {
37531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37532       };
37533     } catch (Dali::DaliException e) {
37534       {
37535         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37536       };
37537     } catch (...) {
37538       {
37539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37540       };
37541     }
37542   }
37543
37544 }
37545
37546
37547 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerBelow(void * jarg1, void * jarg2) {
37548   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37549   Dali::Layer arg2 ;
37550   Dali::Layer *argp2 ;
37551
37552   arg1 = (Dali::Layer *)jarg1;
37553   argp2 = (Dali::Layer *)jarg2;
37554   if (!argp2) {
37555     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37556     return ;
37557   }
37558   arg2 = *argp2;
37559   {
37560     try {
37561       (arg1)->LowerBelow(arg2);
37562     } catch (std::out_of_range& e) {
37563       {
37564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37565       };
37566     } catch (std::exception& e) {
37567       {
37568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37569       };
37570     } catch (Dali::DaliException e) {
37571       {
37572         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37573       };
37574     } catch (...) {
37575       {
37576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37577       };
37578     }
37579   }
37580
37581 }
37582
37583
37584 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseToTop(void * jarg1) {
37585   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37586
37587   arg1 = (Dali::Layer *)jarg1;
37588   {
37589     try {
37590       (arg1)->RaiseToTop();
37591     } catch (std::out_of_range& e) {
37592       {
37593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37594       };
37595     } catch (std::exception& e) {
37596       {
37597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37598       };
37599     } catch (Dali::DaliException e) {
37600       {
37601         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37602       };
37603     } catch (...) {
37604       {
37605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37606       };
37607     }
37608   }
37609
37610 }
37611
37612
37613 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerToBottom(void * jarg1) {
37614   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37615
37616   arg1 = (Dali::Layer *)jarg1;
37617   {
37618     try {
37619       (arg1)->LowerToBottom();
37620     } catch (std::out_of_range& e) {
37621       {
37622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37623       };
37624     } catch (std::exception& e) {
37625       {
37626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37627       };
37628     } catch (Dali::DaliException e) {
37629       {
37630         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37631       };
37632     } catch (...) {
37633       {
37634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37635       };
37636     }
37637   }
37638
37639 }
37640
37641
37642 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveAbove(void * jarg1, void * jarg2) {
37643   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37644   Dali::Layer arg2 ;
37645   Dali::Layer *argp2 ;
37646
37647   arg1 = (Dali::Layer *)jarg1;
37648   argp2 = (Dali::Layer *)jarg2;
37649   if (!argp2) {
37650     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37651     return ;
37652   }
37653   arg2 = *argp2;
37654   {
37655     try {
37656       (arg1)->MoveAbove(arg2);
37657     } catch (std::out_of_range& e) {
37658       {
37659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37660       };
37661     } catch (std::exception& e) {
37662       {
37663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37664       };
37665     } catch (Dali::DaliException e) {
37666       {
37667         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37668       };
37669     } catch (...) {
37670       {
37671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37672       };
37673     }
37674   }
37675
37676 }
37677
37678
37679 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveBelow(void * jarg1, void * jarg2) {
37680   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37681   Dali::Layer arg2 ;
37682   Dali::Layer *argp2 ;
37683
37684   arg1 = (Dali::Layer *)jarg1;
37685   argp2 = (Dali::Layer *)jarg2;
37686   if (!argp2) {
37687     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37688     return ;
37689   }
37690   arg2 = *argp2;
37691   {
37692     try {
37693       (arg1)->MoveBelow(arg2);
37694     } catch (std::out_of_range& e) {
37695       {
37696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37697       };
37698     } catch (std::exception& e) {
37699       {
37700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37701       };
37702     } catch (Dali::DaliException e) {
37703       {
37704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37705       };
37706     } catch (...) {
37707       {
37708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37709       };
37710     }
37711   }
37712
37713 }
37714
37715
37716 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetBehavior(void * jarg1, int jarg2) {
37717   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37718   Dali::Layer::Behavior arg2 ;
37719
37720   arg1 = (Dali::Layer *)jarg1;
37721   arg2 = (Dali::Layer::Behavior)jarg2;
37722   {
37723     try {
37724       (arg1)->SetBehavior(arg2);
37725     } catch (std::out_of_range& e) {
37726       {
37727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37728       };
37729     } catch (std::exception& e) {
37730       {
37731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37732       };
37733     } catch (Dali::DaliException e) {
37734       {
37735         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37736       };
37737     } catch (...) {
37738       {
37739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37740       };
37741     }
37742   }
37743
37744 }
37745
37746
37747 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_GetBehavior(void * jarg1) {
37748   int jresult ;
37749   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37750   Dali::Layer::Behavior result;
37751
37752   arg1 = (Dali::Layer *)jarg1;
37753   {
37754     try {
37755       result = (Dali::Layer::Behavior)((Dali::Layer const *)arg1)->GetBehavior();
37756     } catch (std::out_of_range& e) {
37757       {
37758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37759       };
37760     } catch (std::exception& e) {
37761       {
37762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37763       };
37764     } catch (Dali::DaliException e) {
37765       {
37766         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37767       };
37768     } catch (...) {
37769       {
37770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37771       };
37772     }
37773   }
37774
37775   jresult = (int)result;
37776   return jresult;
37777 }
37778
37779
37780 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClipping(void * jarg1, unsigned int jarg2) {
37781   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37782   bool arg2 ;
37783
37784   arg1 = (Dali::Layer *)jarg1;
37785   arg2 = jarg2 ? true : false;
37786   {
37787     try {
37788       (arg1)->SetClipping(arg2);
37789     } catch (std::out_of_range& e) {
37790       {
37791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37792       };
37793     } catch (std::exception& e) {
37794       {
37795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37796       };
37797     } catch (Dali::DaliException e) {
37798       {
37799         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37800       };
37801     } catch (...) {
37802       {
37803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37804       };
37805     }
37806   }
37807
37808 }
37809
37810
37811 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsClipping(void * jarg1) {
37812   unsigned int jresult ;
37813   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37814   bool result;
37815
37816   arg1 = (Dali::Layer *)jarg1;
37817   {
37818     try {
37819       result = (bool)((Dali::Layer const *)arg1)->IsClipping();
37820     } catch (std::out_of_range& e) {
37821       {
37822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37823       };
37824     } catch (std::exception& e) {
37825       {
37826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37827       };
37828     } catch (Dali::DaliException e) {
37829       {
37830         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37831       };
37832     } catch (...) {
37833       {
37834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37835       };
37836     }
37837   }
37838
37839   jresult = result;
37840   return jresult;
37841 }
37842
37843
37844 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_0(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
37845   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37846   int arg2 ;
37847   int arg3 ;
37848   int arg4 ;
37849   int arg5 ;
37850
37851   arg1 = (Dali::Layer *)jarg1;
37852   arg2 = (int)jarg2;
37853   arg3 = (int)jarg3;
37854   arg4 = (int)jarg4;
37855   arg5 = (int)jarg5;
37856   {
37857     try {
37858       (arg1)->SetClippingBox(arg2,arg3,arg4,arg5);
37859     } catch (std::out_of_range& e) {
37860       {
37861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37862       };
37863     } catch (std::exception& e) {
37864       {
37865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37866       };
37867     } catch (Dali::DaliException e) {
37868       {
37869         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37870       };
37871     } catch (...) {
37872       {
37873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37874       };
37875     }
37876   }
37877
37878 }
37879
37880
37881 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_1(void * jarg1, void * jarg2) {
37882   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37883   Dali::ClippingBox arg2 ;
37884   Dali::ClippingBox *argp2 ;
37885
37886   arg1 = (Dali::Layer *)jarg1;
37887   argp2 = (Dali::ClippingBox *)jarg2;
37888   if (!argp2) {
37889     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ClippingBox", 0);
37890     return ;
37891   }
37892   arg2 = *argp2;
37893   {
37894     try {
37895       (arg1)->SetClippingBox(arg2);
37896     } catch (std::out_of_range& e) {
37897       {
37898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37899       };
37900     } catch (std::exception& e) {
37901       {
37902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37903       };
37904     } catch (Dali::DaliException e) {
37905       {
37906         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37907       };
37908     } catch (...) {
37909       {
37910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37911       };
37912     }
37913   }
37914
37915 }
37916
37917
37918 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_GetClippingBox(void * jarg1) {
37919   void * jresult ;
37920   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37921   Dali::ClippingBox result;
37922
37923   arg1 = (Dali::Layer *)jarg1;
37924   {
37925     try {
37926       result = ((Dali::Layer const *)arg1)->GetClippingBox();
37927     } catch (std::out_of_range& e) {
37928       {
37929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37930       };
37931     } catch (std::exception& e) {
37932       {
37933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37934       };
37935     } catch (Dali::DaliException e) {
37936       {
37937         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37938       };
37939     } catch (...) {
37940       {
37941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37942       };
37943     }
37944   }
37945
37946   jresult = new Dali::ClippingBox((const Dali::ClippingBox &)result);
37947   return jresult;
37948 }
37949
37950
37951 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetDepthTestDisabled(void * jarg1, unsigned int jarg2) {
37952   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37953   bool arg2 ;
37954
37955   arg1 = (Dali::Layer *)jarg1;
37956   arg2 = jarg2 ? true : false;
37957   {
37958     try {
37959       (arg1)->SetDepthTestDisabled(arg2);
37960     } catch (std::out_of_range& e) {
37961       {
37962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37963       };
37964     } catch (std::exception& e) {
37965       {
37966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37967       };
37968     } catch (Dali::DaliException e) {
37969       {
37970         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37971       };
37972     } catch (...) {
37973       {
37974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37975       };
37976     }
37977   }
37978
37979 }
37980
37981
37982 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsDepthTestDisabled(void * jarg1) {
37983   unsigned int jresult ;
37984   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37985   bool result;
37986
37987   arg1 = (Dali::Layer *)jarg1;
37988   {
37989     try {
37990       result = (bool)((Dali::Layer const *)arg1)->IsDepthTestDisabled();
37991     } catch (std::out_of_range& e) {
37992       {
37993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37994       };
37995     } catch (std::exception& e) {
37996       {
37997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37998       };
37999     } catch (Dali::DaliException e) {
38000       {
38001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38002       };
38003     } catch (...) {
38004       {
38005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38006       };
38007     }
38008   }
38009
38010   jresult = result;
38011   return jresult;
38012 }
38013
38014
38015 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetSortFunction(void * jarg1, void * jarg2) {
38016   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38017   Dali::Layer::SortFunctionType arg2 = (Dali::Layer::SortFunctionType) 0 ;
38018
38019   arg1 = (Dali::Layer *)jarg1;
38020   arg2 = (Dali::Layer::SortFunctionType)jarg2;
38021   {
38022     try {
38023       (arg1)->SetSortFunction(arg2);
38024     } catch (std::out_of_range& e) {
38025       {
38026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38027       };
38028     } catch (std::exception& e) {
38029       {
38030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38031       };
38032     } catch (Dali::DaliException e) {
38033       {
38034         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38035       };
38036     } catch (...) {
38037       {
38038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38039       };
38040     }
38041   }
38042
38043 }
38044
38045
38046 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetTouchConsumed(void * jarg1, unsigned int jarg2) {
38047   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38048   bool arg2 ;
38049
38050   arg1 = (Dali::Layer *)jarg1;
38051   arg2 = jarg2 ? true : false;
38052   {
38053     try {
38054       (arg1)->SetTouchConsumed(arg2);
38055     } catch (std::out_of_range& e) {
38056       {
38057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38058       };
38059     } catch (std::exception& e) {
38060       {
38061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38062       };
38063     } catch (Dali::DaliException e) {
38064       {
38065         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38066       };
38067     } catch (...) {
38068       {
38069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38070       };
38071     }
38072   }
38073
38074 }
38075
38076
38077 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsTouchConsumed(void * jarg1) {
38078   unsigned int jresult ;
38079   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38080   bool result;
38081
38082   arg1 = (Dali::Layer *)jarg1;
38083   {
38084     try {
38085       result = (bool)((Dali::Layer const *)arg1)->IsTouchConsumed();
38086     } catch (std::out_of_range& e) {
38087       {
38088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38089       };
38090     } catch (std::exception& e) {
38091       {
38092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38093       };
38094     } catch (Dali::DaliException e) {
38095       {
38096         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38097       };
38098     } catch (...) {
38099       {
38100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38101       };
38102     }
38103   }
38104
38105   jresult = result;
38106   return jresult;
38107 }
38108
38109
38110 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetHoverConsumed(void * jarg1, unsigned int jarg2) {
38111   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38112   bool arg2 ;
38113
38114   arg1 = (Dali::Layer *)jarg1;
38115   arg2 = jarg2 ? true : false;
38116   {
38117     try {
38118       (arg1)->SetHoverConsumed(arg2);
38119     } catch (std::out_of_range& e) {
38120       {
38121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38122       };
38123     } catch (std::exception& e) {
38124       {
38125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38126       };
38127     } catch (Dali::DaliException e) {
38128       {
38129         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38130       };
38131     } catch (...) {
38132       {
38133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38134       };
38135     }
38136   }
38137
38138 }
38139
38140
38141 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsHoverConsumed(void * jarg1) {
38142   unsigned int jresult ;
38143   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38144   bool result;
38145
38146   arg1 = (Dali::Layer *)jarg1;
38147   {
38148     try {
38149       result = (bool)((Dali::Layer const *)arg1)->IsHoverConsumed();
38150     } catch (std::out_of_range& e) {
38151       {
38152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38153       };
38154     } catch (std::exception& e) {
38155       {
38156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38157       };
38158     } catch (Dali::DaliException e) {
38159       {
38160         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38161       };
38162     } catch (...) {
38163       {
38164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38165       };
38166     }
38167   }
38168
38169   jresult = result;
38170   return jresult;
38171 }
38172
38173
38174 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_DEFAULT_BACKGROUND_COLOR_get() {
38175   void * jresult ;
38176   Dali::Vector4 *result = 0 ;
38177
38178   result = (Dali::Vector4 *)&Dali::Stage::DEFAULT_BACKGROUND_COLOR;
38179   jresult = (void *)result;
38180   return jresult;
38181 }
38182
38183
38184 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_DEBUG_BACKGROUND_COLOR_get() {
38185   void * jresult ;
38186   Dali::Vector4 *result = 0 ;
38187
38188   result = (Dali::Vector4 *)&Dali::Stage::DEBUG_BACKGROUND_COLOR;
38189   jresult = (void *)result;
38190   return jresult;
38191 }
38192
38193
38194 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Stage__SWIG_0() {
38195   void * jresult ;
38196   Dali::Stage *result = 0 ;
38197
38198   {
38199     try {
38200       result = (Dali::Stage *)new Dali::Stage();
38201     } catch (std::out_of_range& e) {
38202       {
38203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38204       };
38205     } catch (std::exception& e) {
38206       {
38207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38208       };
38209     } catch (Dali::DaliException e) {
38210       {
38211         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38212       };
38213     } catch (...) {
38214       {
38215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38216       };
38217     }
38218   }
38219
38220   jresult = (void *)result;
38221   return jresult;
38222 }
38223
38224
38225 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetCurrent() {
38226   void * jresult ;
38227   Dali::Stage result;
38228
38229   {
38230     try {
38231       result = Dali::Stage::GetCurrent();
38232     } catch (std::out_of_range& e) {
38233       {
38234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38235       };
38236     } catch (std::exception& e) {
38237       {
38238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38239       };
38240     } catch (Dali::DaliException e) {
38241       {
38242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38243       };
38244     } catch (...) {
38245       {
38246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38247       };
38248     }
38249   }
38250
38251   jresult = new Dali::Stage((const Dali::Stage &)result);
38252   return jresult;
38253 }
38254
38255
38256 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_IsInstalled() {
38257   unsigned int jresult ;
38258   bool result;
38259
38260   {
38261     try {
38262       result = (bool)Dali::Stage::IsInstalled();
38263     } catch (std::out_of_range& e) {
38264       {
38265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38266       };
38267     } catch (std::exception& e) {
38268       {
38269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38270       };
38271     } catch (Dali::DaliException e) {
38272       {
38273         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38274       };
38275     } catch (...) {
38276       {
38277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38278       };
38279     }
38280   }
38281
38282   jresult = result;
38283   return jresult;
38284 }
38285
38286
38287 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Stage(void * jarg1) {
38288   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38289
38290   arg1 = (Dali::Stage *)jarg1;
38291   {
38292     try {
38293       delete arg1;
38294     } catch (std::out_of_range& e) {
38295       {
38296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38297       };
38298     } catch (std::exception& e) {
38299       {
38300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38301       };
38302     } catch (Dali::DaliException e) {
38303       {
38304         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38305       };
38306     } catch (...) {
38307       {
38308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38309       };
38310     }
38311   }
38312
38313 }
38314
38315
38316 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Stage__SWIG_1(void * jarg1) {
38317   void * jresult ;
38318   Dali::Stage *arg1 = 0 ;
38319   Dali::Stage *result = 0 ;
38320
38321   arg1 = (Dali::Stage *)jarg1;
38322   if (!arg1) {
38323     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Stage const & type is null", 0);
38324     return 0;
38325   }
38326   {
38327     try {
38328       result = (Dali::Stage *)new Dali::Stage((Dali::Stage const &)*arg1);
38329     } catch (std::out_of_range& e) {
38330       {
38331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38332       };
38333     } catch (std::exception& e) {
38334       {
38335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38336       };
38337     } catch (Dali::DaliException e) {
38338       {
38339         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38340       };
38341     } catch (...) {
38342       {
38343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38344       };
38345     }
38346   }
38347
38348   jresult = (void *)result;
38349   return jresult;
38350 }
38351
38352
38353 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_Assign(void * jarg1, void * jarg2) {
38354   void * jresult ;
38355   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38356   Dali::Stage *arg2 = 0 ;
38357   Dali::Stage *result = 0 ;
38358
38359   arg1 = (Dali::Stage *)jarg1;
38360   arg2 = (Dali::Stage *)jarg2;
38361   if (!arg2) {
38362     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Stage const & type is null", 0);
38363     return 0;
38364   }
38365   {
38366     try {
38367       result = (Dali::Stage *) &(arg1)->operator =((Dali::Stage const &)*arg2);
38368     } catch (std::out_of_range& e) {
38369       {
38370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38371       };
38372     } catch (std::exception& e) {
38373       {
38374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38375       };
38376     } catch (Dali::DaliException e) {
38377       {
38378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38379       };
38380     } catch (...) {
38381       {
38382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38383       };
38384     }
38385   }
38386
38387   jresult = (void *)result;
38388   return jresult;
38389 }
38390
38391
38392 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_Add(void * jarg1, void * jarg2) {
38393   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38394   Dali::Actor *arg2 = 0 ;
38395
38396   arg1 = (Dali::Stage *)jarg1;
38397   arg2 = (Dali::Actor *)jarg2;
38398   if (!arg2) {
38399     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
38400     return ;
38401   }
38402   {
38403     try {
38404       (arg1)->Add(*arg2);
38405     } catch (std::out_of_range& e) {
38406       {
38407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38408       };
38409     } catch (std::exception& e) {
38410       {
38411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38412       };
38413     } catch (Dali::DaliException e) {
38414       {
38415         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38416       };
38417     } catch (...) {
38418       {
38419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38420       };
38421     }
38422   }
38423
38424 }
38425
38426
38427 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_Remove(void * jarg1, void * jarg2) {
38428   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38429   Dali::Actor *arg2 = 0 ;
38430
38431   arg1 = (Dali::Stage *)jarg1;
38432   arg2 = (Dali::Actor *)jarg2;
38433   if (!arg2) {
38434     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
38435     return ;
38436   }
38437   {
38438     try {
38439       (arg1)->Remove(*arg2);
38440     } catch (std::out_of_range& e) {
38441       {
38442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38443       };
38444     } catch (std::exception& e) {
38445       {
38446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38447       };
38448     } catch (Dali::DaliException e) {
38449       {
38450         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38451       };
38452     } catch (...) {
38453       {
38454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38455       };
38456     }
38457   }
38458
38459 }
38460
38461
38462 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetSize(void * jarg1) {
38463   void * jresult ;
38464   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38465   Dali::Vector2 result;
38466
38467   arg1 = (Dali::Stage *)jarg1;
38468   {
38469     try {
38470       result = ((Dali::Stage const *)arg1)->GetSize();
38471     } catch (std::out_of_range& e) {
38472       {
38473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38474       };
38475     } catch (std::exception& e) {
38476       {
38477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38478       };
38479     } catch (Dali::DaliException e) {
38480       {
38481         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38482       };
38483     } catch (...) {
38484       {
38485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38486       };
38487     }
38488   }
38489
38490   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
38491   return jresult;
38492 }
38493
38494
38495 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetRenderTaskList(void * jarg1) {
38496   void * jresult ;
38497   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38498   Dali::RenderTaskList result;
38499
38500   arg1 = (Dali::Stage *)jarg1;
38501   {
38502     try {
38503       result = ((Dali::Stage const *)arg1)->GetRenderTaskList();
38504     } catch (std::out_of_range& e) {
38505       {
38506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38507       };
38508     } catch (std::exception& e) {
38509       {
38510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38511       };
38512     } catch (Dali::DaliException e) {
38513       {
38514         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38515       };
38516     } catch (...) {
38517       {
38518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38519       };
38520     }
38521   }
38522
38523   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
38524   return jresult;
38525 }
38526
38527
38528 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_GetLayerCount(void * jarg1) {
38529   unsigned int jresult ;
38530   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38531   unsigned int result;
38532
38533   arg1 = (Dali::Stage *)jarg1;
38534   {
38535     try {
38536       result = (unsigned int)((Dali::Stage const *)arg1)->GetLayerCount();
38537     } catch (std::out_of_range& e) {
38538       {
38539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38540       };
38541     } catch (std::exception& e) {
38542       {
38543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38544       };
38545     } catch (Dali::DaliException e) {
38546       {
38547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38548       };
38549     } catch (...) {
38550       {
38551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38552       };
38553     }
38554   }
38555
38556   jresult = result;
38557   return jresult;
38558 }
38559
38560
38561 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetLayer(void * jarg1, unsigned int jarg2) {
38562   void * jresult ;
38563   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38564   unsigned int arg2 ;
38565   Dali::Layer result;
38566
38567   arg1 = (Dali::Stage *)jarg1;
38568   arg2 = (unsigned int)jarg2;
38569   {
38570     try {
38571       result = ((Dali::Stage const *)arg1)->GetLayer(arg2);
38572     } catch (std::out_of_range& e) {
38573       {
38574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38575       };
38576     } catch (std::exception& e) {
38577       {
38578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38579       };
38580     } catch (Dali::DaliException e) {
38581       {
38582         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38583       };
38584     } catch (...) {
38585       {
38586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38587       };
38588     }
38589   }
38590
38591   jresult = new Dali::Layer((const Dali::Layer &)result);
38592   return jresult;
38593 }
38594
38595
38596 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetRootLayer(void * jarg1) {
38597   void * jresult ;
38598   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38599   Dali::Layer result;
38600
38601   arg1 = (Dali::Stage *)jarg1;
38602   {
38603     try {
38604       result = ((Dali::Stage const *)arg1)->GetRootLayer();
38605     } catch (std::out_of_range& e) {
38606       {
38607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38608       };
38609     } catch (std::exception& e) {
38610       {
38611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38612       };
38613     } catch (Dali::DaliException e) {
38614       {
38615         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38616       };
38617     } catch (...) {
38618       {
38619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38620       };
38621     }
38622   }
38623
38624   jresult = new Dali::Layer((const Dali::Layer &)result);
38625   return jresult;
38626 }
38627
38628
38629 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_SetBackgroundColor(void * jarg1, void * jarg2) {
38630   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38631   Dali::Vector4 arg2 ;
38632   Dali::Vector4 *argp2 ;
38633
38634   arg1 = (Dali::Stage *)jarg1;
38635   argp2 = (Dali::Vector4 *)jarg2;
38636   if (!argp2) {
38637     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector4", 0);
38638     return ;
38639   }
38640   arg2 = *argp2;
38641   {
38642     try {
38643       (arg1)->SetBackgroundColor(arg2);
38644     } catch (std::out_of_range& e) {
38645       {
38646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38647       };
38648     } catch (std::exception& e) {
38649       {
38650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38651       };
38652     } catch (Dali::DaliException e) {
38653       {
38654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38655       };
38656     } catch (...) {
38657       {
38658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38659       };
38660     }
38661   }
38662
38663 }
38664
38665
38666 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetBackgroundColor(void * jarg1) {
38667   void * jresult ;
38668   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38669   Dali::Vector4 result;
38670
38671   arg1 = (Dali::Stage *)jarg1;
38672   {
38673     try {
38674       result = ((Dali::Stage const *)arg1)->GetBackgroundColor();
38675     } catch (std::out_of_range& e) {
38676       {
38677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38678       };
38679     } catch (std::exception& e) {
38680       {
38681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38682       };
38683     } catch (Dali::DaliException e) {
38684       {
38685         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38686       };
38687     } catch (...) {
38688       {
38689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38690       };
38691     }
38692   }
38693
38694   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
38695   return jresult;
38696 }
38697
38698
38699 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetDpi(void * jarg1) {
38700   void * jresult ;
38701   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38702   Dali::Vector2 result;
38703
38704   arg1 = (Dali::Stage *)jarg1;
38705   {
38706     try {
38707       result = ((Dali::Stage const *)arg1)->GetDpi();
38708     } catch (std::out_of_range& e) {
38709       {
38710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38711       };
38712     } catch (std::exception& e) {
38713       {
38714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38715       };
38716     } catch (Dali::DaliException e) {
38717       {
38718         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38719       };
38720     } catch (...) {
38721       {
38722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38723       };
38724     }
38725   }
38726
38727   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
38728   return jresult;
38729 }
38730
38731
38732 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetObjectRegistry(void * jarg1) {
38733   void * jresult ;
38734   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38735   Dali::ObjectRegistry result;
38736
38737   arg1 = (Dali::Stage *)jarg1;
38738   {
38739     try {
38740       result = ((Dali::Stage const *)arg1)->GetObjectRegistry();
38741     } catch (std::out_of_range& e) {
38742       {
38743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38744       };
38745     } catch (std::exception& e) {
38746       {
38747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38748       };
38749     } catch (Dali::DaliException e) {
38750       {
38751         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38752       };
38753     } catch (...) {
38754       {
38755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38756       };
38757     }
38758   }
38759
38760   jresult = new Dali::ObjectRegistry((const Dali::ObjectRegistry &)result);
38761   return jresult;
38762 }
38763
38764
38765 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_KeepRendering(void * jarg1, float jarg2) {
38766   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38767   float arg2 ;
38768
38769   arg1 = (Dali::Stage *)jarg1;
38770   arg2 = (float)jarg2;
38771   {
38772     try {
38773       (arg1)->KeepRendering(arg2);
38774     } catch (std::out_of_range& e) {
38775       {
38776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38777       };
38778     } catch (std::exception& e) {
38779       {
38780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38781       };
38782     } catch (Dali::DaliException e) {
38783       {
38784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38785       };
38786     } catch (...) {
38787       {
38788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38789       };
38790     }
38791   }
38792
38793 }
38794
38795
38796 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_KeyEventSignal(void * jarg1) {
38797   void * jresult ;
38798   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38799   Dali::Stage::KeyEventSignalType *result = 0 ;
38800
38801   arg1 = (Dali::Stage *)jarg1;
38802   {
38803     try {
38804       result = (Dali::Stage::KeyEventSignalType *) &(arg1)->KeyEventSignal();
38805     } catch (std::out_of_range& e) {
38806       {
38807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38808       };
38809     } catch (std::exception& e) {
38810       {
38811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38812       };
38813     } catch (Dali::DaliException e) {
38814       {
38815         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38816       };
38817     } catch (...) {
38818       {
38819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38820       };
38821     }
38822   }
38823
38824   jresult = (void *)result;
38825   return jresult;
38826 }
38827
38828
38829 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_EventProcessingFinishedSignal(void * jarg1) {
38830   void * jresult ;
38831   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38832   Dali::Stage::EventProcessingFinishedSignalType *result = 0 ;
38833
38834   arg1 = (Dali::Stage *)jarg1;
38835   {
38836     try {
38837       result = (Dali::Stage::EventProcessingFinishedSignalType *) &(arg1)->EventProcessingFinishedSignal();
38838     } catch (std::out_of_range& e) {
38839       {
38840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38841       };
38842     } catch (std::exception& e) {
38843       {
38844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38845       };
38846     } catch (Dali::DaliException e) {
38847       {
38848         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38849       };
38850     } catch (...) {
38851       {
38852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38853       };
38854     }
38855   }
38856
38857   jresult = (void *)result;
38858   return jresult;
38859 }
38860
38861
38862 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_TouchSignal(void * jarg1) {
38863   void * jresult ;
38864   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38865   Dali::Stage::TouchSignalType *result = 0 ;
38866
38867   arg1 = (Dali::Stage *)jarg1;
38868   {
38869     try {
38870       result = (Dali::Stage::TouchSignalType *) &(arg1)->TouchSignal();
38871     } catch (std::out_of_range& e) {
38872       {
38873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38874       };
38875     } catch (std::exception& e) {
38876       {
38877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38878       };
38879     } catch (Dali::DaliException e) {
38880       {
38881         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38882       };
38883     } catch (...) {
38884       {
38885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38886       };
38887     }
38888   }
38889
38890   jresult = (void *)result;
38891   return jresult;
38892 }
38893
38894
38895 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_WheelEventSignal(void * jarg1) {
38896   void * jresult ;
38897   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38898   Dali::Stage::WheelEventSignalType *result = 0 ;
38899
38900   arg1 = (Dali::Stage *)jarg1;
38901   {
38902     try {
38903       result = (Dali::Stage::WheelEventSignalType *) &(arg1)->WheelEventSignal();
38904     } catch (std::out_of_range& e) {
38905       {
38906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38907       };
38908     } catch (std::exception& e) {
38909       {
38910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38911       };
38912     } catch (Dali::DaliException e) {
38913       {
38914         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38915       };
38916     } catch (...) {
38917       {
38918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38919       };
38920     }
38921   }
38922
38923   jresult = (void *)result;
38924   return jresult;
38925 }
38926
38927
38928 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextLostSignal(void * jarg1) {
38929   void * jresult ;
38930   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38931   Dali::Stage::ContextStatusSignal *result = 0 ;
38932
38933   arg1 = (Dali::Stage *)jarg1;
38934   {
38935     try {
38936       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextLostSignal();
38937     } catch (std::out_of_range& e) {
38938       {
38939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38940       };
38941     } catch (std::exception& e) {
38942       {
38943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38944       };
38945     } catch (Dali::DaliException e) {
38946       {
38947         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38948       };
38949     } catch (...) {
38950       {
38951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38952       };
38953     }
38954   }
38955
38956   jresult = (void *)result;
38957   return jresult;
38958 }
38959
38960
38961 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextRegainedSignal(void * jarg1) {
38962   void * jresult ;
38963   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38964   Dali::Stage::ContextStatusSignal *result = 0 ;
38965
38966   arg1 = (Dali::Stage *)jarg1;
38967   {
38968     try {
38969       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextRegainedSignal();
38970     } catch (std::out_of_range& e) {
38971       {
38972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38973       };
38974     } catch (std::exception& e) {
38975       {
38976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38977       };
38978     } catch (Dali::DaliException e) {
38979       {
38980         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38981       };
38982     } catch (...) {
38983       {
38984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38985       };
38986     }
38987   }
38988
38989   jresult = (void *)result;
38990   return jresult;
38991 }
38992
38993
38994 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_SceneCreatedSignal(void * jarg1) {
38995   void * jresult ;
38996   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38997   Dali::Stage::SceneCreatedSignalType *result = 0 ;
38998
38999   arg1 = (Dali::Stage *)jarg1;
39000   {
39001     try {
39002       result = (Dali::Stage::SceneCreatedSignalType *) &(arg1)->SceneCreatedSignal();
39003     } catch (std::out_of_range& e) {
39004       {
39005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39006       };
39007     } catch (std::exception& e) {
39008       {
39009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39010       };
39011     } catch (Dali::DaliException e) {
39012       {
39013         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39014       };
39015     } catch (...) {
39016       {
39017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39018       };
39019     }
39020   }
39021
39022   jresult = (void *)result;
39023   return jresult;
39024 }
39025
39026 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_SetRenderingBehavior(void * jarg1, int jarg2) {
39027   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
39028   Dali::DevelStage::Rendering arg2 ;
39029
39030   arg1 = (Dali::Stage *)jarg1;
39031   arg2 = (Dali::DevelStage::Rendering)jarg2;
39032   {
39033     try {
39034       DevelStage::SetRenderingBehavior(*arg1,arg2);
39035     } catch (std::out_of_range& e) {
39036       {
39037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39038       };
39039     } catch (std::exception& e) {
39040       {
39041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39042       };
39043     } catch (Dali::DaliException e) {
39044       {
39045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39046       };
39047     } catch (...) {
39048       {
39049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39050       };
39051     }
39052   }
39053
39054 }
39055
39056 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Stage_GetRenderingBehavior(void * jarg1) {
39057
39058   int jresult ;
39059   int result ;
39060   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
39061
39062   arg1 = (Dali::Stage *)jarg1;
39063   {
39064     try {
39065       result = (int)(DevelStage::GetRenderingBehavior(*arg1));
39066     } catch (std::out_of_range& e) {
39067       {
39068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39069       };
39070     } catch (std::exception& e) {
39071       {
39072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39073       };
39074     } catch (Dali::DaliException e) {
39075       {
39076         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39077       };
39078     } catch (...) {
39079       {
39080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39081       };
39082     }
39083   }
39084
39085   jresult = result;
39086   return jresult;
39087 }
39088
39089 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RelayoutContainer(void * jarg1) {
39090   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
39091
39092   arg1 = (Dali::RelayoutContainer *)jarg1;
39093   {
39094     try {
39095       delete arg1;
39096     } catch (std::out_of_range& e) {
39097       {
39098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39099       };
39100     } catch (std::exception& e) {
39101       {
39102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39103       };
39104     } catch (Dali::DaliException e) {
39105       {
39106         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39107       };
39108     } catch (...) {
39109       {
39110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39111       };
39112     }
39113   }
39114
39115 }
39116
39117
39118 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RelayoutContainer_Add(void * jarg1, void * jarg2, void * jarg3) {
39119   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
39120   Dali::Actor *arg2 = 0 ;
39121   Dali::Vector2 *arg3 = 0 ;
39122
39123   arg1 = (Dali::RelayoutContainer *)jarg1;
39124   arg2 = (Dali::Actor *)jarg2;
39125   if (!arg2) {
39126     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
39127     return ;
39128   }
39129   arg3 = (Dali::Vector2 *)jarg3;
39130   if (!arg3) {
39131     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
39132     return ;
39133   }
39134   {
39135     try {
39136       (arg1)->Add((Dali::Actor const &)*arg2,(Dali::Vector2 const &)*arg3);
39137     } catch (std::out_of_range& e) {
39138       {
39139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39140       };
39141     } catch (std::exception& e) {
39142       {
39143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39144       };
39145     } catch (Dali::DaliException e) {
39146       {
39147         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39148       };
39149     } catch (...) {
39150       {
39151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39152       };
39153     }
39154   }
39155
39156 }
39157
39158
39159 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_Self(void * jarg1) {
39160   void * jresult ;
39161   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39162   Dali::CustomActor result;
39163
39164   arg1 = (Dali::CustomActorImpl *)jarg1;
39165   {
39166     try {
39167       result = ((Dali::CustomActorImpl const *)arg1)->Self();
39168     } catch (std::out_of_range& e) {
39169       {
39170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39171       };
39172     } catch (std::exception& e) {
39173       {
39174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39175       };
39176     } catch (Dali::DaliException e) {
39177       {
39178         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39179       };
39180     } catch (...) {
39181       {
39182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39183       };
39184     }
39185   }
39186
39187   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
39188   return jresult;
39189 }
39190
39191
39192 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnStageConnection(void * jarg1, int jarg2) {
39193   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39194   int arg2 ;
39195
39196   arg1 = (Dali::CustomActorImpl *)jarg1;
39197   arg2 = (int)jarg2;
39198   {
39199     try {
39200       (arg1)->OnStageConnection(arg2);
39201     } catch (std::out_of_range& e) {
39202       {
39203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39204       };
39205     } catch (std::exception& e) {
39206       {
39207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39208       };
39209     } catch (Dali::DaliException e) {
39210       {
39211         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39212       };
39213     } catch (...) {
39214       {
39215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39216       };
39217     }
39218   }
39219
39220 }
39221
39222
39223 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnStageDisconnection(void * jarg1) {
39224   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39225
39226   arg1 = (Dali::CustomActorImpl *)jarg1;
39227   {
39228     try {
39229       (arg1)->OnStageDisconnection();
39230     } catch (std::out_of_range& e) {
39231       {
39232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39233       };
39234     } catch (std::exception& e) {
39235       {
39236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39237       };
39238     } catch (Dali::DaliException e) {
39239       {
39240         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39241       };
39242     } catch (...) {
39243       {
39244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39245       };
39246     }
39247   }
39248
39249 }
39250
39251
39252 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildAdd(void * jarg1, void * jarg2) {
39253   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39254   Dali::Actor *arg2 = 0 ;
39255
39256   arg1 = (Dali::CustomActorImpl *)jarg1;
39257   arg2 = (Dali::Actor *)jarg2;
39258   if (!arg2) {
39259     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
39260     return ;
39261   }
39262   {
39263     try {
39264       (arg1)->OnChildAdd(*arg2);
39265     } catch (std::out_of_range& e) {
39266       {
39267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39268       };
39269     } catch (std::exception& e) {
39270       {
39271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39272       };
39273     } catch (Dali::DaliException e) {
39274       {
39275         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39276       };
39277     } catch (...) {
39278       {
39279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39280       };
39281     }
39282   }
39283
39284 }
39285
39286
39287 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildRemove(void * jarg1, void * jarg2) {
39288   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39289   Dali::Actor *arg2 = 0 ;
39290
39291   arg1 = (Dali::CustomActorImpl *)jarg1;
39292   arg2 = (Dali::Actor *)jarg2;
39293   if (!arg2) {
39294     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
39295     return ;
39296   }
39297   {
39298     try {
39299       (arg1)->OnChildRemove(*arg2);
39300     } catch (std::out_of_range& e) {
39301       {
39302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39303       };
39304     } catch (std::exception& e) {
39305       {
39306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39307       };
39308     } catch (Dali::DaliException e) {
39309       {
39310         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39311       };
39312     } catch (...) {
39313       {
39314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39315       };
39316     }
39317   }
39318
39319 }
39320
39321
39322 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
39323   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39324   Dali::Property::Index arg2 ;
39325   Dali::Property::Value arg3 ;
39326   Dali::Property::Value *argp3 ;
39327
39328   arg1 = (Dali::CustomActorImpl *)jarg1;
39329   arg2 = (Dali::Property::Index)jarg2;
39330   argp3 = (Dali::Property::Value *)jarg3;
39331   if (!argp3) {
39332     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39333     return ;
39334   }
39335   arg3 = *argp3;
39336   {
39337     try {
39338       (arg1)->OnPropertySet(arg2,arg3);
39339     } catch (std::out_of_range& e) {
39340       {
39341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39342       };
39343     } catch (std::exception& e) {
39344       {
39345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39346       };
39347     } catch (Dali::DaliException e) {
39348       {
39349         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39350       };
39351     } catch (...) {
39352       {
39353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39354       };
39355     }
39356   }
39357
39358 }
39359
39360
39361 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeSet(void * jarg1, void * jarg2) {
39362   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39363   Dali::Vector3 *arg2 = 0 ;
39364
39365   arg1 = (Dali::CustomActorImpl *)jarg1;
39366   arg2 = (Dali::Vector3 *)jarg2;
39367   if (!arg2) {
39368     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
39369     return ;
39370   }
39371   {
39372     try {
39373       (arg1)->OnSizeSet((Dali::Vector3 const &)*arg2);
39374     } catch (std::out_of_range& e) {
39375       {
39376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39377       };
39378     } catch (std::exception& e) {
39379       {
39380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39381       };
39382     } catch (Dali::DaliException e) {
39383       {
39384         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39385       };
39386     } catch (...) {
39387       {
39388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39389       };
39390     }
39391   }
39392
39393 }
39394
39395 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
39396   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39397   Dali::Animation *arg2 = 0 ;
39398   Dali::Vector3 *arg3 = 0 ;
39399
39400   arg1 = (Dali::CustomActorImpl *)jarg1;
39401   arg2 = (Dali::Animation *)jarg2;
39402   if (!arg2) {
39403     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
39404     return ;
39405   }
39406   arg3 = (Dali::Vector3 *)jarg3;
39407   if (!arg3) {
39408     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
39409     return ;
39410   }
39411   {
39412     try {
39413       (arg1)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
39414     } catch (std::out_of_range& e) {
39415       {
39416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39417       };
39418     } catch (std::exception& e) {
39419       {
39420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39421       };
39422     } catch (Dali::DaliException e) {
39423       {
39424         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39425       };
39426     } catch (...) {
39427       {
39428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39429       };
39430     }
39431   }
39432
39433 }
39434
39435
39436 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnTouchEvent(void * jarg1, void * jarg2) {
39437   unsigned int jresult ;
39438   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39439   Dali::TouchEvent *arg2 = 0 ;
39440   bool result;
39441
39442   arg1 = (Dali::CustomActorImpl *)jarg1;
39443   arg2 = (Dali::TouchEvent *)jarg2;
39444   if (!arg2) {
39445     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
39446     return 0;
39447   }
39448   {
39449     try {
39450       result = (bool)(arg1)->OnTouchEvent((Dali::TouchEvent const &)*arg2);
39451     } catch (std::out_of_range& e) {
39452       {
39453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39454       };
39455     } catch (std::exception& e) {
39456       {
39457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39458       };
39459     } catch (Dali::DaliException e) {
39460       {
39461         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39462       };
39463     } catch (...) {
39464       {
39465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39466       };
39467     }
39468   }
39469
39470   jresult = result;
39471   return jresult;
39472 }
39473
39474
39475 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnHoverEvent(void * jarg1, void * jarg2) {
39476   unsigned int jresult ;
39477   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39478   Dali::HoverEvent *arg2 = 0 ;
39479   bool result;
39480
39481   arg1 = (Dali::CustomActorImpl *)jarg1;
39482   arg2 = (Dali::HoverEvent *)jarg2;
39483   if (!arg2) {
39484     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
39485     return 0;
39486   }
39487   {
39488     try {
39489       result = (bool)(arg1)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
39490     } catch (std::out_of_range& e) {
39491       {
39492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39493       };
39494     } catch (std::exception& e) {
39495       {
39496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39497       };
39498     } catch (Dali::DaliException e) {
39499       {
39500         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39501       };
39502     } catch (...) {
39503       {
39504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39505       };
39506     }
39507   }
39508
39509   jresult = result;
39510   return jresult;
39511 }
39512
39513
39514 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnKeyEvent(void * jarg1, void * jarg2) {
39515   unsigned int jresult ;
39516   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39517   Dali::KeyEvent *arg2 = 0 ;
39518   bool result;
39519
39520   arg1 = (Dali::CustomActorImpl *)jarg1;
39521   arg2 = (Dali::KeyEvent *)jarg2;
39522   if (!arg2) {
39523     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
39524     return 0;
39525   }
39526   {
39527     try {
39528       result = (bool)(arg1)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
39529     } catch (std::out_of_range& e) {
39530       {
39531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39532       };
39533     } catch (std::exception& e) {
39534       {
39535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39536       };
39537     } catch (Dali::DaliException e) {
39538       {
39539         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39540       };
39541     } catch (...) {
39542       {
39543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39544       };
39545     }
39546   }
39547
39548   jresult = result;
39549   return jresult;
39550 }
39551
39552
39553 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnWheelEvent(void * jarg1, void * jarg2) {
39554   unsigned int jresult ;
39555   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39556   Dali::WheelEvent *arg2 = 0 ;
39557   bool result;
39558
39559   arg1 = (Dali::CustomActorImpl *)jarg1;
39560   arg2 = (Dali::WheelEvent *)jarg2;
39561   if (!arg2) {
39562     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
39563     return 0;
39564   }
39565   {
39566     try {
39567       result = (bool)(arg1)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
39568     } catch (std::out_of_range& e) {
39569       {
39570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39571       };
39572     } catch (std::exception& e) {
39573       {
39574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39575       };
39576     } catch (Dali::DaliException e) {
39577       {
39578         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39579       };
39580     } catch (...) {
39581       {
39582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39583       };
39584     }
39585   }
39586
39587   jresult = result;
39588   return jresult;
39589 }
39590
39591
39592 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
39593   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39594   Dali::Vector2 *arg2 = 0 ;
39595   Dali::RelayoutContainer *arg3 = 0 ;
39596
39597   arg1 = (Dali::CustomActorImpl *)jarg1;
39598   arg2 = (Dali::Vector2 *)jarg2;
39599   if (!arg2) {
39600     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
39601     return ;
39602   }
39603   arg3 = (Dali::RelayoutContainer *)jarg3;
39604   if (!arg3) {
39605     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
39606     return ;
39607   }
39608   {
39609     try {
39610       (arg1)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
39611     } catch (std::out_of_range& e) {
39612       {
39613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39614       };
39615     } catch (std::exception& e) {
39616       {
39617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39618       };
39619     } catch (Dali::DaliException e) {
39620       {
39621         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39622       };
39623     } catch (...) {
39624       {
39625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39626       };
39627     }
39628   }
39629
39630 }
39631
39632
39633 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
39634   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39635   Dali::ResizePolicy::Type arg2 ;
39636   Dali::Dimension::Type arg3 ;
39637
39638   arg1 = (Dali::CustomActorImpl *)jarg1;
39639   arg2 = (Dali::ResizePolicy::Type)jarg2;
39640   arg3 = (Dali::Dimension::Type)jarg3;
39641   {
39642     try {
39643       (arg1)->OnSetResizePolicy(arg2,arg3);
39644     } catch (std::out_of_range& e) {
39645       {
39646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39647       };
39648     } catch (std::exception& e) {
39649       {
39650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39651       };
39652     } catch (Dali::DaliException e) {
39653       {
39654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39655       };
39656     } catch (...) {
39657       {
39658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39659       };
39660     }
39661   }
39662
39663 }
39664
39665
39666 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetNaturalSize(void * jarg1) {
39667   void * jresult ;
39668   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39669   Dali::Vector3 result;
39670
39671   arg1 = (Dali::CustomActorImpl *)jarg1;
39672   {
39673     try {
39674       result = (arg1)->GetNaturalSize();
39675     } catch (std::out_of_range& e) {
39676       {
39677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39678       };
39679     } catch (std::exception& e) {
39680       {
39681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39682       };
39683     } catch (Dali::DaliException e) {
39684       {
39685         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39686       };
39687     } catch (...) {
39688       {
39689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39690       };
39691     }
39692   }
39693
39694   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
39695   return jresult;
39696 }
39697
39698
39699 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
39700   float jresult ;
39701   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39702   Dali::Actor *arg2 = 0 ;
39703   Dali::Dimension::Type arg3 ;
39704   float result;
39705
39706   arg1 = (Dali::CustomActorImpl *)jarg1;
39707   arg2 = (Dali::Actor *)jarg2;
39708   if (!arg2) {
39709     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
39710     return 0;
39711   }
39712   arg3 = (Dali::Dimension::Type)jarg3;
39713   {
39714     try {
39715       result = (float)(arg1)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
39716     } catch (std::out_of_range& e) {
39717       {
39718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39719       };
39720     } catch (std::exception& e) {
39721       {
39722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39723       };
39724     } catch (Dali::DaliException e) {
39725       {
39726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39727       };
39728     } catch (...) {
39729       {
39730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39731       };
39732     }
39733   }
39734
39735   jresult = result;
39736   return jresult;
39737 }
39738
39739
39740 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetHeightForWidth(void * jarg1, float jarg2) {
39741   float jresult ;
39742   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39743   float arg2 ;
39744   float result;
39745
39746   arg1 = (Dali::CustomActorImpl *)jarg1;
39747   arg2 = (float)jarg2;
39748   {
39749     try {
39750       result = (float)(arg1)->GetHeightForWidth(arg2);
39751     } catch (std::out_of_range& e) {
39752       {
39753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39754       };
39755     } catch (std::exception& e) {
39756       {
39757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39758       };
39759     } catch (Dali::DaliException e) {
39760       {
39761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39762       };
39763     } catch (...) {
39764       {
39765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39766       };
39767     }
39768   }
39769
39770   jresult = result;
39771   return jresult;
39772 }
39773
39774
39775 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetWidthForHeight(void * jarg1, float jarg2) {
39776   float jresult ;
39777   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39778   float arg2 ;
39779   float result;
39780
39781   arg1 = (Dali::CustomActorImpl *)jarg1;
39782   arg2 = (float)jarg2;
39783   {
39784     try {
39785       result = (float)(arg1)->GetWidthForHeight(arg2);
39786     } catch (std::out_of_range& e) {
39787       {
39788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39789       };
39790     } catch (std::exception& e) {
39791       {
39792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39793       };
39794     } catch (Dali::DaliException e) {
39795       {
39796         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39797       };
39798     } catch (...) {
39799       {
39800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39801       };
39802     }
39803   }
39804
39805   jresult = result;
39806   return jresult;
39807 }
39808
39809
39810 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
39811   unsigned int jresult ;
39812   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39813   Dali::Dimension::Type arg2 ;
39814   bool result;
39815
39816   arg1 = (Dali::CustomActorImpl *)jarg1;
39817   arg2 = (Dali::Dimension::Type)jarg2;
39818   {
39819     try {
39820       result = (bool)(arg1)->RelayoutDependentOnChildren(arg2);
39821     } catch (std::out_of_range& e) {
39822       {
39823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39824       };
39825     } catch (std::exception& e) {
39826       {
39827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39828       };
39829     } catch (Dali::DaliException e) {
39830       {
39831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39832       };
39833     } catch (...) {
39834       {
39835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39836       };
39837     }
39838   }
39839
39840   jresult = result;
39841   return jresult;
39842 }
39843
39844
39845 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
39846   unsigned int jresult ;
39847   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39848   bool result;
39849
39850   arg1 = (Dali::CustomActorImpl *)jarg1;
39851   {
39852     try {
39853       result = (bool)(arg1)->RelayoutDependentOnChildren();
39854     } catch (std::out_of_range& e) {
39855       {
39856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39857       };
39858     } catch (std::exception& e) {
39859       {
39860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39861       };
39862     } catch (Dali::DaliException e) {
39863       {
39864         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39865       };
39866     } catch (...) {
39867       {
39868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39869       };
39870     }
39871   }
39872
39873   jresult = result;
39874   return jresult;
39875 }
39876
39877
39878 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
39879   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39880   Dali::Dimension::Type arg2 ;
39881
39882   arg1 = (Dali::CustomActorImpl *)jarg1;
39883   arg2 = (Dali::Dimension::Type)jarg2;
39884   {
39885     try {
39886       (arg1)->OnCalculateRelayoutSize(arg2);
39887     } catch (std::out_of_range& e) {
39888       {
39889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39890       };
39891     } catch (std::exception& e) {
39892       {
39893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39894       };
39895     } catch (Dali::DaliException e) {
39896       {
39897         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39898       };
39899     } catch (...) {
39900       {
39901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39902       };
39903     }
39904   }
39905
39906 }
39907
39908
39909 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
39910   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39911   float arg2 ;
39912   Dali::Dimension::Type arg3 ;
39913
39914   arg1 = (Dali::CustomActorImpl *)jarg1;
39915   arg2 = (float)jarg2;
39916   arg3 = (Dali::Dimension::Type)jarg3;
39917   {
39918     try {
39919       (arg1)->OnLayoutNegotiated(arg2,arg3);
39920     } catch (std::out_of_range& e) {
39921       {
39922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39923       };
39924     } catch (std::exception& e) {
39925       {
39926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39927       };
39928     } catch (Dali::DaliException e) {
39929       {
39930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39931       };
39932     } catch (...) {
39933       {
39934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39935       };
39936     }
39937   }
39938
39939 }
39940
39941
39942 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresTouchEvents(void * jarg1) {
39943   unsigned int jresult ;
39944   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39945   bool result;
39946
39947   arg1 = (Dali::CustomActorImpl *)jarg1;
39948   {
39949     try {
39950       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresTouchEvents();
39951     } catch (std::out_of_range& e) {
39952       {
39953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39954       };
39955     } catch (std::exception& e) {
39956       {
39957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39958       };
39959     } catch (Dali::DaliException e) {
39960       {
39961         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39962       };
39963     } catch (...) {
39964       {
39965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39966       };
39967     }
39968   }
39969
39970   jresult = result;
39971   return jresult;
39972 }
39973
39974
39975 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresHoverEvents(void * jarg1) {
39976   unsigned int jresult ;
39977   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39978   bool result;
39979
39980   arg1 = (Dali::CustomActorImpl *)jarg1;
39981   {
39982     try {
39983       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresHoverEvents();
39984     } catch (std::out_of_range& e) {
39985       {
39986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39987       };
39988     } catch (std::exception& e) {
39989       {
39990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39991       };
39992     } catch (Dali::DaliException e) {
39993       {
39994         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39995       };
39996     } catch (...) {
39997       {
39998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39999       };
40000     }
40001   }
40002
40003   jresult = result;
40004   return jresult;
40005 }
40006
40007
40008 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresWheelEvents(void * jarg1) {
40009   unsigned int jresult ;
40010   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
40011   bool result;
40012
40013   arg1 = (Dali::CustomActorImpl *)jarg1;
40014   {
40015     try {
40016       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresWheelEvents();
40017     } catch (std::out_of_range& e) {
40018       {
40019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40020       };
40021     } catch (std::exception& e) {
40022       {
40023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40024       };
40025     } catch (Dali::DaliException e) {
40026       {
40027         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40028       };
40029     } catch (...) {
40030       {
40031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40032       };
40033     }
40034   }
40035
40036   jresult = result;
40037   return jresult;
40038 }
40039
40040
40041 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_IsRelayoutEnabled(void * jarg1) {
40042   unsigned int jresult ;
40043   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
40044   bool result;
40045
40046   arg1 = (Dali::CustomActorImpl *)jarg1;
40047   {
40048     try {
40049       result = (bool)((Dali::CustomActorImpl const *)arg1)->IsRelayoutEnabled();
40050     } catch (std::out_of_range& e) {
40051       {
40052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40053       };
40054     } catch (std::exception& e) {
40055       {
40056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40057       };
40058     } catch (Dali::DaliException e) {
40059       {
40060         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40061       };
40062     } catch (...) {
40063       {
40064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40065       };
40066     }
40067   }
40068
40069   jresult = result;
40070   return jresult;
40071 }
40072
40073
40074 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_0() {
40075   void * jresult ;
40076   Dali::CustomActor *result = 0 ;
40077
40078   {
40079     try {
40080       result = (Dali::CustomActor *)new Dali::CustomActor();
40081     } catch (std::out_of_range& e) {
40082       {
40083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40084       };
40085     } catch (std::exception& e) {
40086       {
40087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40088       };
40089     } catch (Dali::DaliException e) {
40090       {
40091         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40092       };
40093     } catch (...) {
40094       {
40095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40096       };
40097     }
40098   }
40099
40100   jresult = (void *)result;
40101   return jresult;
40102 }
40103
40104
40105 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_DownCast(void * jarg1) {
40106   void * jresult ;
40107   Dali::BaseHandle arg1 ;
40108   Dali::BaseHandle *argp1 ;
40109   Dali::CustomActor result;
40110
40111   argp1 = (Dali::BaseHandle *)jarg1;
40112   if (!argp1) {
40113     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40114     return 0;
40115   }
40116   arg1 = *argp1;
40117   {
40118     try {
40119       result = Dali::CustomActor::DownCast(arg1);
40120     } catch (std::out_of_range& e) {
40121       {
40122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40123       };
40124     } catch (std::exception& e) {
40125       {
40126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40127       };
40128     } catch (Dali::DaliException e) {
40129       {
40130         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40131       };
40132     } catch (...) {
40133       {
40134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40135       };
40136     }
40137   }
40138
40139   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
40140   return jresult;
40141 }
40142
40143
40144 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomActor(void * jarg1) {
40145   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
40146
40147   arg1 = (Dali::CustomActor *)jarg1;
40148   {
40149     try {
40150       delete arg1;
40151     } catch (std::out_of_range& e) {
40152       {
40153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40154       };
40155     } catch (std::exception& e) {
40156       {
40157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40158       };
40159     } catch (Dali::DaliException e) {
40160       {
40161         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40162       };
40163     } catch (...) {
40164       {
40165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40166       };
40167     }
40168   }
40169
40170 }
40171
40172
40173 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_GetImplementation(void * jarg1) {
40174   void * jresult ;
40175   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
40176   Dali::CustomActorImpl *result = 0 ;
40177
40178   arg1 = (Dali::CustomActor *)jarg1;
40179   {
40180     try {
40181       result = (Dali::CustomActorImpl *) &((Dali::CustomActor const *)arg1)->GetImplementation();
40182     } catch (std::out_of_range& e) {
40183       {
40184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40185       };
40186     } catch (std::exception& e) {
40187       {
40188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40189       };
40190     } catch (Dali::DaliException e) {
40191       {
40192         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40193       };
40194     } catch (...) {
40195       {
40196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40197       };
40198     }
40199   }
40200
40201   jresult = (void *)result;
40202   return jresult;
40203 }
40204
40205
40206 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_1(void * jarg1) {
40207   void * jresult ;
40208   Dali::CustomActorImpl *arg1 = 0 ;
40209   Dali::CustomActor *result = 0 ;
40210
40211   arg1 = (Dali::CustomActorImpl *)jarg1;
40212   if (!arg1) {
40213     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActorImpl & type is null", 0);
40214     return 0;
40215   }
40216   {
40217     try {
40218       result = (Dali::CustomActor *)new Dali::CustomActor(*arg1);
40219     } catch (std::out_of_range& e) {
40220       {
40221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40222       };
40223     } catch (std::exception& e) {
40224       {
40225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40226       };
40227     } catch (Dali::DaliException e) {
40228       {
40229         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40230       };
40231     } catch (...) {
40232       {
40233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40234       };
40235     }
40236   }
40237
40238   jresult = (void *)result;
40239   return jresult;
40240 }
40241
40242
40243 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_2(void * jarg1) {
40244   void * jresult ;
40245   Dali::CustomActor *arg1 = 0 ;
40246   Dali::CustomActor *result = 0 ;
40247
40248   arg1 = (Dali::CustomActor *)jarg1;
40249   if (!arg1) {
40250     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
40251     return 0;
40252   }
40253   {
40254     try {
40255       result = (Dali::CustomActor *)new Dali::CustomActor((Dali::CustomActor const &)*arg1);
40256     } catch (std::out_of_range& e) {
40257       {
40258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40259       };
40260     } catch (std::exception& e) {
40261       {
40262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40263       };
40264     } catch (Dali::DaliException e) {
40265       {
40266         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40267       };
40268     } catch (...) {
40269       {
40270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40271       };
40272     }
40273   }
40274
40275   jresult = (void *)result;
40276   return jresult;
40277 }
40278
40279
40280 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_Assign(void * jarg1, void * jarg2) {
40281   void * jresult ;
40282   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
40283   Dali::CustomActor *arg2 = 0 ;
40284   Dali::CustomActor *result = 0 ;
40285
40286   arg1 = (Dali::CustomActor *)jarg1;
40287   arg2 = (Dali::CustomActor *)jarg2;
40288   if (!arg2) {
40289     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
40290     return 0;
40291   }
40292   {
40293     try {
40294       result = (Dali::CustomActor *) &(arg1)->operator =((Dali::CustomActor const &)*arg2);
40295     } catch (std::out_of_range& e) {
40296       {
40297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40298       };
40299     } catch (std::exception& e) {
40300       {
40301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40302       };
40303     } catch (Dali::DaliException e) {
40304       {
40305         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40306       };
40307     } catch (...) {
40308       {
40309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40310       };
40311     }
40312   }
40313
40314   jresult = (void *)result;
40315   return jresult;
40316 }
40317
40318
40319 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_POSITION_get() {
40320   int jresult ;
40321   int result;
40322
40323   result = (int)Dali::PanGestureDetector::Property::SCREEN_POSITION;
40324   jresult = (int)result;
40325   return jresult;
40326 }
40327
40328
40329 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_DISPLACEMENT_get() {
40330   int jresult ;
40331   int result;
40332
40333   result = (int)Dali::PanGestureDetector::Property::SCREEN_DISPLACEMENT;
40334   jresult = (int)result;
40335   return jresult;
40336 }
40337
40338
40339 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_VELOCITY_get() {
40340   int jresult ;
40341   int result;
40342
40343   result = (int)Dali::PanGestureDetector::Property::SCREEN_VELOCITY;
40344   jresult = (int)result;
40345   return jresult;
40346 }
40347
40348
40349 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_POSITION_get() {
40350   int jresult ;
40351   int result;
40352
40353   result = (int)Dali::PanGestureDetector::Property::LOCAL_POSITION;
40354   jresult = (int)result;
40355   return jresult;
40356 }
40357
40358
40359 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_DISPLACEMENT_get() {
40360   int jresult ;
40361   int result;
40362
40363   result = (int)Dali::PanGestureDetector::Property::LOCAL_DISPLACEMENT;
40364   jresult = (int)result;
40365   return jresult;
40366 }
40367
40368
40369 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_VELOCITY_get() {
40370   int jresult ;
40371   int result;
40372
40373   result = (int)Dali::PanGestureDetector::Property::LOCAL_VELOCITY;
40374   jresult = (int)result;
40375   return jresult;
40376 }
40377
40378
40379 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_PANNING_get() {
40380   int jresult ;
40381   int result;
40382
40383   result = (int)Dali::PanGestureDetector::Property::PANNING;
40384   jresult = (int)result;
40385   return jresult;
40386 }
40387
40388
40389 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector_Property() {
40390   void * jresult ;
40391   Dali::PanGestureDetector::Property *result = 0 ;
40392
40393   {
40394     try {
40395       result = (Dali::PanGestureDetector::Property *)new Dali::PanGestureDetector::Property();
40396     } catch (std::out_of_range& e) {
40397       {
40398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40399       };
40400     } catch (std::exception& e) {
40401       {
40402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40403       };
40404     } catch (Dali::DaliException e) {
40405       {
40406         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40407       };
40408     } catch (...) {
40409       {
40410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40411       };
40412     }
40413   }
40414
40415   jresult = (void *)result;
40416   return jresult;
40417 }
40418
40419
40420 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector_Property(void * jarg1) {
40421   Dali::PanGestureDetector::Property *arg1 = (Dali::PanGestureDetector::Property *) 0 ;
40422
40423   arg1 = (Dali::PanGestureDetector::Property *)jarg1;
40424   {
40425     try {
40426       delete arg1;
40427     } catch (std::out_of_range& e) {
40428       {
40429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40430       };
40431     } catch (std::exception& e) {
40432       {
40433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40434       };
40435     } catch (Dali::DaliException e) {
40436       {
40437         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40438       };
40439     } catch (...) {
40440       {
40441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40442       };
40443     }
40444   }
40445
40446 }
40447
40448
40449 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_LEFT_get() {
40450   void * jresult ;
40451   Dali::Radian *result = 0 ;
40452
40453   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_LEFT;
40454   jresult = (void *)result;
40455   return jresult;
40456 }
40457
40458
40459 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_RIGHT_get() {
40460   void * jresult ;
40461   Dali::Radian *result = 0 ;
40462
40463   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_RIGHT;
40464   jresult = (void *)result;
40465   return jresult;
40466 }
40467
40468
40469 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_UP_get() {
40470   void * jresult ;
40471   Dali::Radian *result = 0 ;
40472
40473   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_UP;
40474   jresult = (void *)result;
40475   return jresult;
40476 }
40477
40478
40479 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_DOWN_get() {
40480   void * jresult ;
40481   Dali::Radian *result = 0 ;
40482
40483   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_DOWN;
40484   jresult = (void *)result;
40485   return jresult;
40486 }
40487
40488
40489 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_HORIZONTAL_get() {
40490   void * jresult ;
40491   Dali::Radian *result = 0 ;
40492
40493   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_HORIZONTAL;
40494   jresult = (void *)result;
40495   return jresult;
40496 }
40497
40498
40499 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_VERTICAL_get() {
40500   void * jresult ;
40501   Dali::Radian *result = 0 ;
40502
40503   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_VERTICAL;
40504   jresult = (void *)result;
40505   return jresult;
40506 }
40507
40508
40509 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DEFAULT_THRESHOLD_get() {
40510   void * jresult ;
40511   Dali::Radian *result = 0 ;
40512
40513   result = (Dali::Radian *)&Dali::PanGestureDetector::DEFAULT_THRESHOLD;
40514   jresult = (void *)result;
40515   return jresult;
40516 }
40517
40518
40519 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_0() {
40520   void * jresult ;
40521   Dali::PanGestureDetector *result = 0 ;
40522
40523   {
40524     try {
40525       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector();
40526     } catch (std::out_of_range& e) {
40527       {
40528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40529       };
40530     } catch (std::exception& e) {
40531       {
40532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40533       };
40534     } catch (Dali::DaliException e) {
40535       {
40536         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40537       };
40538     } catch (...) {
40539       {
40540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40541       };
40542     }
40543   }
40544
40545   jresult = (void *)result;
40546   return jresult;
40547 }
40548
40549
40550 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_New() {
40551   void * jresult ;
40552   Dali::PanGestureDetector result;
40553
40554   {
40555     try {
40556       result = Dali::PanGestureDetector::New();
40557     } catch (std::out_of_range& e) {
40558       {
40559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40560       };
40561     } catch (std::exception& e) {
40562       {
40563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40564       };
40565     } catch (Dali::DaliException e) {
40566       {
40567         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40568       };
40569     } catch (...) {
40570       {
40571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40572       };
40573     }
40574   }
40575
40576   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
40577   return jresult;
40578 }
40579
40580
40581 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DownCast(void * jarg1) {
40582   void * jresult ;
40583   Dali::BaseHandle arg1 ;
40584   Dali::BaseHandle *argp1 ;
40585   Dali::PanGestureDetector result;
40586
40587   argp1 = (Dali::BaseHandle *)jarg1;
40588   if (!argp1) {
40589     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40590     return 0;
40591   }
40592   arg1 = *argp1;
40593   {
40594     try {
40595       result = Dali::PanGestureDetector::DownCast(arg1);
40596     } catch (std::out_of_range& e) {
40597       {
40598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40599       };
40600     } catch (std::exception& e) {
40601       {
40602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40603       };
40604     } catch (Dali::DaliException e) {
40605       {
40606         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40607       };
40608     } catch (...) {
40609       {
40610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40611       };
40612     }
40613   }
40614
40615   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
40616   return jresult;
40617 }
40618
40619
40620 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector(void * jarg1) {
40621   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40622
40623   arg1 = (Dali::PanGestureDetector *)jarg1;
40624   {
40625     try {
40626       delete arg1;
40627     } catch (std::out_of_range& e) {
40628       {
40629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40630       };
40631     } catch (std::exception& e) {
40632       {
40633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40634       };
40635     } catch (Dali::DaliException e) {
40636       {
40637         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40638       };
40639     } catch (...) {
40640       {
40641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40642       };
40643     }
40644   }
40645
40646 }
40647
40648
40649 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_1(void * jarg1) {
40650   void * jresult ;
40651   Dali::PanGestureDetector *arg1 = 0 ;
40652   Dali::PanGestureDetector *result = 0 ;
40653
40654   arg1 = (Dali::PanGestureDetector *)jarg1;
40655   if (!arg1) {
40656     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
40657     return 0;
40658   }
40659   {
40660     try {
40661       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector((Dali::PanGestureDetector const &)*arg1);
40662     } catch (std::out_of_range& e) {
40663       {
40664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40665       };
40666     } catch (std::exception& e) {
40667       {
40668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40669       };
40670     } catch (Dali::DaliException e) {
40671       {
40672         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40673       };
40674     } catch (...) {
40675       {
40676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40677       };
40678     }
40679   }
40680
40681   jresult = (void *)result;
40682   return jresult;
40683 }
40684
40685
40686 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_Assign(void * jarg1, void * jarg2) {
40687   void * jresult ;
40688   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40689   Dali::PanGestureDetector *arg2 = 0 ;
40690   Dali::PanGestureDetector *result = 0 ;
40691
40692   arg1 = (Dali::PanGestureDetector *)jarg1;
40693   arg2 = (Dali::PanGestureDetector *)jarg2;
40694   if (!arg2) {
40695     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
40696     return 0;
40697   }
40698   {
40699     try {
40700       result = (Dali::PanGestureDetector *) &(arg1)->operator =((Dali::PanGestureDetector const &)*arg2);
40701     } catch (std::out_of_range& e) {
40702       {
40703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40704       };
40705     } catch (std::exception& e) {
40706       {
40707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40708       };
40709     } catch (Dali::DaliException e) {
40710       {
40711         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40712       };
40713     } catch (...) {
40714       {
40715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40716       };
40717     }
40718   }
40719
40720   jresult = (void *)result;
40721   return jresult;
40722 }
40723
40724
40725 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMinimumTouchesRequired(void * jarg1, unsigned int jarg2) {
40726   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40727   unsigned int arg2 ;
40728
40729   arg1 = (Dali::PanGestureDetector *)jarg1;
40730   arg2 = (unsigned int)jarg2;
40731   {
40732     try {
40733       (arg1)->SetMinimumTouchesRequired(arg2);
40734     } catch (std::out_of_range& e) {
40735       {
40736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40737       };
40738     } catch (std::exception& e) {
40739       {
40740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40741       };
40742     } catch (Dali::DaliException e) {
40743       {
40744         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40745       };
40746     } catch (...) {
40747       {
40748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40749       };
40750     }
40751   }
40752
40753 }
40754
40755
40756 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMaximumTouchesRequired(void * jarg1, unsigned int jarg2) {
40757   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40758   unsigned int arg2 ;
40759
40760   arg1 = (Dali::PanGestureDetector *)jarg1;
40761   arg2 = (unsigned int)jarg2;
40762   {
40763     try {
40764       (arg1)->SetMaximumTouchesRequired(arg2);
40765     } catch (std::out_of_range& e) {
40766       {
40767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40768       };
40769     } catch (std::exception& e) {
40770       {
40771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40772       };
40773     } catch (Dali::DaliException e) {
40774       {
40775         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40776       };
40777     } catch (...) {
40778       {
40779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40780       };
40781     }
40782   }
40783
40784 }
40785
40786
40787 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
40788   unsigned int jresult ;
40789   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40790   unsigned int result;
40791
40792   arg1 = (Dali::PanGestureDetector *)jarg1;
40793   {
40794     try {
40795       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMinimumTouchesRequired();
40796     } catch (std::out_of_range& e) {
40797       {
40798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40799       };
40800     } catch (std::exception& e) {
40801       {
40802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40803       };
40804     } catch (Dali::DaliException e) {
40805       {
40806         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40807       };
40808     } catch (...) {
40809       {
40810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40811       };
40812     }
40813   }
40814
40815   jresult = result;
40816   return jresult;
40817 }
40818
40819
40820 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
40821   unsigned int jresult ;
40822   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40823   unsigned int result;
40824
40825   arg1 = (Dali::PanGestureDetector *)jarg1;
40826   {
40827     try {
40828       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMaximumTouchesRequired();
40829     } catch (std::out_of_range& e) {
40830       {
40831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40832       };
40833     } catch (std::exception& e) {
40834       {
40835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40836       };
40837     } catch (Dali::DaliException e) {
40838       {
40839         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40840       };
40841     } catch (...) {
40842       {
40843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40844       };
40845     }
40846   }
40847
40848   jresult = result;
40849   return jresult;
40850 }
40851
40852
40853 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
40854   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40855   Dali::Radian arg2 ;
40856   Dali::Radian arg3 ;
40857   Dali::Radian *argp2 ;
40858   Dali::Radian *argp3 ;
40859
40860   arg1 = (Dali::PanGestureDetector *)jarg1;
40861   argp2 = (Dali::Radian *)jarg2;
40862   if (!argp2) {
40863     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40864     return ;
40865   }
40866   arg2 = *argp2;
40867   argp3 = (Dali::Radian *)jarg3;
40868   if (!argp3) {
40869     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40870     return ;
40871   }
40872   arg3 = *argp3;
40873   {
40874     try {
40875       (arg1)->AddAngle(arg2,arg3);
40876     } catch (std::out_of_range& e) {
40877       {
40878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40879       };
40880     } catch (std::exception& e) {
40881       {
40882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40883       };
40884     } catch (Dali::DaliException e) {
40885       {
40886         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40887       };
40888     } catch (...) {
40889       {
40890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40891       };
40892     }
40893   }
40894
40895 }
40896
40897
40898 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_1(void * jarg1, void * jarg2) {
40899   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40900   Dali::Radian arg2 ;
40901   Dali::Radian *argp2 ;
40902
40903   arg1 = (Dali::PanGestureDetector *)jarg1;
40904   argp2 = (Dali::Radian *)jarg2;
40905   if (!argp2) {
40906     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40907     return ;
40908   }
40909   arg2 = *argp2;
40910   {
40911     try {
40912       (arg1)->AddAngle(arg2);
40913     } catch (std::out_of_range& e) {
40914       {
40915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40916       };
40917     } catch (std::exception& e) {
40918       {
40919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40920       };
40921     } catch (Dali::DaliException e) {
40922       {
40923         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40924       };
40925     } catch (...) {
40926       {
40927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40928       };
40929     }
40930   }
40931
40932 }
40933
40934
40935 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
40936   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40937   Dali::Radian arg2 ;
40938   Dali::Radian arg3 ;
40939   Dali::Radian *argp2 ;
40940   Dali::Radian *argp3 ;
40941
40942   arg1 = (Dali::PanGestureDetector *)jarg1;
40943   argp2 = (Dali::Radian *)jarg2;
40944   if (!argp2) {
40945     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40946     return ;
40947   }
40948   arg2 = *argp2;
40949   argp3 = (Dali::Radian *)jarg3;
40950   if (!argp3) {
40951     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40952     return ;
40953   }
40954   arg3 = *argp3;
40955   {
40956     try {
40957       (arg1)->AddDirection(arg2,arg3);
40958     } catch (std::out_of_range& e) {
40959       {
40960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40961       };
40962     } catch (std::exception& e) {
40963       {
40964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40965       };
40966     } catch (Dali::DaliException e) {
40967       {
40968         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40969       };
40970     } catch (...) {
40971       {
40972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40973       };
40974     }
40975   }
40976
40977 }
40978
40979
40980 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_1(void * jarg1, void * jarg2) {
40981   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40982   Dali::Radian arg2 ;
40983   Dali::Radian *argp2 ;
40984
40985   arg1 = (Dali::PanGestureDetector *)jarg1;
40986   argp2 = (Dali::Radian *)jarg2;
40987   if (!argp2) {
40988     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40989     return ;
40990   }
40991   arg2 = *argp2;
40992   {
40993     try {
40994       (arg1)->AddDirection(arg2);
40995     } catch (std::out_of_range& e) {
40996       {
40997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40998       };
40999     } catch (std::exception& e) {
41000       {
41001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41002       };
41003     } catch (Dali::DaliException e) {
41004       {
41005         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41006       };
41007     } catch (...) {
41008       {
41009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41010       };
41011     }
41012   }
41013
41014 }
41015
41016
41017 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngleCount(void * jarg1) {
41018   unsigned long jresult ;
41019   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41020   size_t result;
41021
41022   arg1 = (Dali::PanGestureDetector *)jarg1;
41023   {
41024     try {
41025       result = ((Dali::PanGestureDetector const *)arg1)->GetAngleCount();
41026     } catch (std::out_of_range& e) {
41027       {
41028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41029       };
41030     } catch (std::exception& e) {
41031       {
41032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41033       };
41034     } catch (Dali::DaliException e) {
41035       {
41036         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41037       };
41038     } catch (...) {
41039       {
41040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41041       };
41042     }
41043   }
41044
41045   jresult = (unsigned long)result;
41046   return jresult;
41047 }
41048
41049
41050 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngle(void * jarg1, unsigned long jarg2) {
41051   void * jresult ;
41052   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41053   size_t arg2 ;
41054   Dali::PanGestureDetector::AngleThresholdPair result;
41055
41056   arg1 = (Dali::PanGestureDetector *)jarg1;
41057   arg2 = (size_t)jarg2;
41058   {
41059     try {
41060       result = ((Dali::PanGestureDetector const *)arg1)->GetAngle(arg2);
41061     } catch (std::out_of_range& e) {
41062       {
41063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41064       };
41065     } catch (std::exception& e) {
41066       {
41067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41068       };
41069     } catch (Dali::DaliException e) {
41070       {
41071         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41072       };
41073     } catch (...) {
41074       {
41075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41076       };
41077     }
41078   }
41079
41080   jresult = new Dali::PanGestureDetector::AngleThresholdPair((const Dali::PanGestureDetector::AngleThresholdPair &)result);
41081   return jresult;
41082 }
41083
41084
41085 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_ClearAngles(void * jarg1) {
41086   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41087
41088   arg1 = (Dali::PanGestureDetector *)jarg1;
41089   {
41090     try {
41091       (arg1)->ClearAngles();
41092     } catch (std::out_of_range& e) {
41093       {
41094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41095       };
41096     } catch (std::exception& e) {
41097       {
41098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41099       };
41100     } catch (Dali::DaliException e) {
41101       {
41102         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41103       };
41104     } catch (...) {
41105       {
41106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41107       };
41108     }
41109   }
41110
41111 }
41112
41113
41114 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveAngle(void * jarg1, void * jarg2) {
41115   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41116   Dali::Radian arg2 ;
41117   Dali::Radian *argp2 ;
41118
41119   arg1 = (Dali::PanGestureDetector *)jarg1;
41120   argp2 = (Dali::Radian *)jarg2;
41121   if (!argp2) {
41122     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
41123     return ;
41124   }
41125   arg2 = *argp2;
41126   {
41127     try {
41128       (arg1)->RemoveAngle(arg2);
41129     } catch (std::out_of_range& e) {
41130       {
41131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41132       };
41133     } catch (std::exception& e) {
41134       {
41135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41136       };
41137     } catch (Dali::DaliException e) {
41138       {
41139         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41140       };
41141     } catch (...) {
41142       {
41143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41144       };
41145     }
41146   }
41147
41148 }
41149
41150
41151 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveDirection(void * jarg1, void * jarg2) {
41152   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41153   Dali::Radian arg2 ;
41154   Dali::Radian *argp2 ;
41155
41156   arg1 = (Dali::PanGestureDetector *)jarg1;
41157   argp2 = (Dali::Radian *)jarg2;
41158   if (!argp2) {
41159     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
41160     return ;
41161   }
41162   arg2 = *argp2;
41163   {
41164     try {
41165       (arg1)->RemoveDirection(arg2);
41166     } catch (std::out_of_range& e) {
41167       {
41168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41169       };
41170     } catch (std::exception& e) {
41171       {
41172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41173       };
41174     } catch (Dali::DaliException e) {
41175       {
41176         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41177       };
41178     } catch (...) {
41179       {
41180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41181       };
41182     }
41183   }
41184
41185 }
41186
41187
41188 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DetectedSignal(void * jarg1) {
41189   void * jresult ;
41190   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41191   Dali::PanGestureDetector::DetectedSignalType *result = 0 ;
41192
41193   arg1 = (Dali::PanGestureDetector *)jarg1;
41194   {
41195     try {
41196       result = (Dali::PanGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
41197     } catch (std::out_of_range& e) {
41198       {
41199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41200       };
41201     } catch (std::exception& e) {
41202       {
41203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41204       };
41205     } catch (Dali::DaliException e) {
41206       {
41207         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41208       };
41209     } catch (...) {
41210       {
41211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41212       };
41213     }
41214   }
41215
41216   jresult = (void *)result;
41217   return jresult;
41218 }
41219
41220
41221 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetPanGestureProperties(void * jarg1) {
41222   Dali::PanGesture *arg1 = 0 ;
41223
41224   arg1 = (Dali::PanGesture *)jarg1;
41225   if (!arg1) {
41226     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
41227     return ;
41228   }
41229   {
41230     try {
41231       Dali::PanGestureDetector::SetPanGestureProperties((Dali::PanGesture const &)*arg1);
41232     } catch (std::out_of_range& e) {
41233       {
41234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41235       };
41236     } catch (std::exception& e) {
41237       {
41238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41239       };
41240     } catch (Dali::DaliException e) {
41241       {
41242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41243       };
41244     } catch (...) {
41245       {
41246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41247       };
41248     }
41249   }
41250
41251 }
41252
41253
41254 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_0() {
41255   void * jresult ;
41256   Dali::PanGesture *result = 0 ;
41257
41258   {
41259     try {
41260       result = (Dali::PanGesture *)new Dali::PanGesture();
41261     } catch (std::out_of_range& e) {
41262       {
41263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41264       };
41265     } catch (std::exception& e) {
41266       {
41267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41268       };
41269     } catch (Dali::DaliException e) {
41270       {
41271         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41272       };
41273     } catch (...) {
41274       {
41275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41276       };
41277     }
41278   }
41279
41280   jresult = (void *)result;
41281   return jresult;
41282 }
41283
41284
41285 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_1(int jarg1) {
41286   void * jresult ;
41287   Dali::Gesture::State arg1 ;
41288   Dali::PanGesture *result = 0 ;
41289
41290   arg1 = (Dali::Gesture::State)jarg1;
41291   {
41292     try {
41293       result = (Dali::PanGesture *)new Dali::PanGesture(arg1);
41294     } catch (std::out_of_range& e) {
41295       {
41296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41297       };
41298     } catch (std::exception& e) {
41299       {
41300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41301       };
41302     } catch (Dali::DaliException e) {
41303       {
41304         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41305       };
41306     } catch (...) {
41307       {
41308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41309       };
41310     }
41311   }
41312
41313   jresult = (void *)result;
41314   return jresult;
41315 }
41316
41317
41318 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_2(void * jarg1) {
41319   void * jresult ;
41320   Dali::PanGesture *arg1 = 0 ;
41321   Dali::PanGesture *result = 0 ;
41322
41323   arg1 = (Dali::PanGesture *)jarg1;
41324   if (!arg1) {
41325     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
41326     return 0;
41327   }
41328   {
41329     try {
41330       result = (Dali::PanGesture *)new Dali::PanGesture((Dali::PanGesture const &)*arg1);
41331     } catch (std::out_of_range& e) {
41332       {
41333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41334       };
41335     } catch (std::exception& e) {
41336       {
41337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41338       };
41339     } catch (Dali::DaliException e) {
41340       {
41341         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41342       };
41343     } catch (...) {
41344       {
41345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41346       };
41347     }
41348   }
41349
41350   jresult = (void *)result;
41351   return jresult;
41352 }
41353
41354
41355 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_Assign(void * jarg1, void * jarg2) {
41356   void * jresult ;
41357   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41358   Dali::PanGesture *arg2 = 0 ;
41359   Dali::PanGesture *result = 0 ;
41360
41361   arg1 = (Dali::PanGesture *)jarg1;
41362   arg2 = (Dali::PanGesture *)jarg2;
41363   if (!arg2) {
41364     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
41365     return 0;
41366   }
41367   {
41368     try {
41369       result = (Dali::PanGesture *) &(arg1)->operator =((Dali::PanGesture const &)*arg2);
41370     } catch (std::out_of_range& e) {
41371       {
41372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41373       };
41374     } catch (std::exception& e) {
41375       {
41376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41377       };
41378     } catch (Dali::DaliException e) {
41379       {
41380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41381       };
41382     } catch (...) {
41383       {
41384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41385       };
41386     }
41387   }
41388
41389   jresult = (void *)result;
41390   return jresult;
41391 }
41392
41393
41394 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGesture(void * jarg1) {
41395   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41396
41397   arg1 = (Dali::PanGesture *)jarg1;
41398   {
41399     try {
41400       delete arg1;
41401     } catch (std::out_of_range& e) {
41402       {
41403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41404       };
41405     } catch (std::exception& e) {
41406       {
41407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41408       };
41409     } catch (Dali::DaliException e) {
41410       {
41411         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41412       };
41413     } catch (...) {
41414       {
41415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41416       };
41417     }
41418   }
41419
41420 }
41421
41422
41423 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_velocity_set(void * jarg1, void * jarg2) {
41424   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41425   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41426
41427   arg1 = (Dali::PanGesture *)jarg1;
41428   arg2 = (Dali::Vector2 *)jarg2;
41429   if (arg1) (arg1)->velocity = *arg2;
41430 }
41431
41432
41433 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_velocity_get(void * jarg1) {
41434   void * jresult ;
41435   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41436   Dali::Vector2 *result = 0 ;
41437
41438   arg1 = (Dali::PanGesture *)jarg1;
41439   result = (Dali::Vector2 *)& ((arg1)->velocity);
41440   jresult = (void *)result;
41441   return jresult;
41442 }
41443
41444
41445 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_displacement_set(void * jarg1, void * jarg2) {
41446   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41447   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41448
41449   arg1 = (Dali::PanGesture *)jarg1;
41450   arg2 = (Dali::Vector2 *)jarg2;
41451   if (arg1) (arg1)->displacement = *arg2;
41452 }
41453
41454
41455 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_displacement_get(void * jarg1) {
41456   void * jresult ;
41457   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41458   Dali::Vector2 *result = 0 ;
41459
41460   arg1 = (Dali::PanGesture *)jarg1;
41461   result = (Dali::Vector2 *)& ((arg1)->displacement);
41462   jresult = (void *)result;
41463   return jresult;
41464 }
41465
41466
41467 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_position_set(void * jarg1, void * jarg2) {
41468   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41469   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41470
41471   arg1 = (Dali::PanGesture *)jarg1;
41472   arg2 = (Dali::Vector2 *)jarg2;
41473   if (arg1) (arg1)->position = *arg2;
41474 }
41475
41476
41477 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_position_get(void * jarg1) {
41478   void * jresult ;
41479   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41480   Dali::Vector2 *result = 0 ;
41481
41482   arg1 = (Dali::PanGesture *)jarg1;
41483   result = (Dali::Vector2 *)& ((arg1)->position);
41484   jresult = (void *)result;
41485   return jresult;
41486 }
41487
41488
41489 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_set(void * jarg1, void * jarg2) {
41490   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41491   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41492
41493   arg1 = (Dali::PanGesture *)jarg1;
41494   arg2 = (Dali::Vector2 *)jarg2;
41495   if (arg1) (arg1)->screenVelocity = *arg2;
41496 }
41497
41498
41499 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_get(void * jarg1) {
41500   void * jresult ;
41501   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41502   Dali::Vector2 *result = 0 ;
41503
41504   arg1 = (Dali::PanGesture *)jarg1;
41505   result = (Dali::Vector2 *)& ((arg1)->screenVelocity);
41506   jresult = (void *)result;
41507   return jresult;
41508 }
41509
41510
41511 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_set(void * jarg1, void * jarg2) {
41512   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41513   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41514
41515   arg1 = (Dali::PanGesture *)jarg1;
41516   arg2 = (Dali::Vector2 *)jarg2;
41517   if (arg1) (arg1)->screenDisplacement = *arg2;
41518 }
41519
41520
41521 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_get(void * jarg1) {
41522   void * jresult ;
41523   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41524   Dali::Vector2 *result = 0 ;
41525
41526   arg1 = (Dali::PanGesture *)jarg1;
41527   result = (Dali::Vector2 *)& ((arg1)->screenDisplacement);
41528   jresult = (void *)result;
41529   return jresult;
41530 }
41531
41532
41533 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_set(void * jarg1, void * jarg2) {
41534   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41535   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41536
41537   arg1 = (Dali::PanGesture *)jarg1;
41538   arg2 = (Dali::Vector2 *)jarg2;
41539   if (arg1) (arg1)->screenPosition = *arg2;
41540 }
41541
41542
41543 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_get(void * jarg1) {
41544   void * jresult ;
41545   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41546   Dali::Vector2 *result = 0 ;
41547
41548   arg1 = (Dali::PanGesture *)jarg1;
41549   result = (Dali::Vector2 *)& ((arg1)->screenPosition);
41550   jresult = (void *)result;
41551   return jresult;
41552 }
41553
41554
41555 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
41556   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41557   unsigned int arg2 ;
41558
41559   arg1 = (Dali::PanGesture *)jarg1;
41560   arg2 = (unsigned int)jarg2;
41561   if (arg1) (arg1)->numberOfTouches = arg2;
41562 }
41563
41564
41565 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_get(void * jarg1) {
41566   unsigned int jresult ;
41567   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41568   unsigned int result;
41569
41570   arg1 = (Dali::PanGesture *)jarg1;
41571   result = (unsigned int) ((arg1)->numberOfTouches);
41572   jresult = result;
41573   return jresult;
41574 }
41575
41576
41577 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetSpeed(void * jarg1) {
41578   float jresult ;
41579   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41580   float result;
41581
41582   arg1 = (Dali::PanGesture *)jarg1;
41583   {
41584     try {
41585       result = (float)((Dali::PanGesture const *)arg1)->GetSpeed();
41586     } catch (std::out_of_range& e) {
41587       {
41588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41589       };
41590     } catch (std::exception& e) {
41591       {
41592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41593       };
41594     } catch (Dali::DaliException e) {
41595       {
41596         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41597       };
41598     } catch (...) {
41599       {
41600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41601       };
41602     }
41603   }
41604
41605   jresult = result;
41606   return jresult;
41607 }
41608
41609
41610 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetDistance(void * jarg1) {
41611   float jresult ;
41612   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41613   float result;
41614
41615   arg1 = (Dali::PanGesture *)jarg1;
41616   {
41617     try {
41618       result = (float)((Dali::PanGesture const *)arg1)->GetDistance();
41619     } catch (std::out_of_range& e) {
41620       {
41621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41622       };
41623     } catch (std::exception& e) {
41624       {
41625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41626       };
41627     } catch (Dali::DaliException e) {
41628       {
41629         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41630       };
41631     } catch (...) {
41632       {
41633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41634       };
41635     }
41636   }
41637
41638   jresult = result;
41639   return jresult;
41640 }
41641
41642
41643 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenSpeed(void * jarg1) {
41644   float jresult ;
41645   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41646   float result;
41647
41648   arg1 = (Dali::PanGesture *)jarg1;
41649   {
41650     try {
41651       result = (float)((Dali::PanGesture const *)arg1)->GetScreenSpeed();
41652     } catch (std::out_of_range& e) {
41653       {
41654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41655       };
41656     } catch (std::exception& e) {
41657       {
41658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41659       };
41660     } catch (Dali::DaliException e) {
41661       {
41662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41663       };
41664     } catch (...) {
41665       {
41666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41667       };
41668     }
41669   }
41670
41671   jresult = result;
41672   return jresult;
41673 }
41674
41675
41676 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenDistance(void * jarg1) {
41677   float jresult ;
41678   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41679   float result;
41680
41681   arg1 = (Dali::PanGesture *)jarg1;
41682   {
41683     try {
41684       result = (float)((Dali::PanGesture const *)arg1)->GetScreenDistance();
41685     } catch (std::out_of_range& e) {
41686       {
41687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41688       };
41689     } catch (std::exception& e) {
41690       {
41691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41692       };
41693     } catch (Dali::DaliException e) {
41694       {
41695         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41696       };
41697     } catch (...) {
41698       {
41699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41700       };
41701     }
41702   }
41703
41704   jresult = result;
41705   return jresult;
41706 }
41707
41708
41709 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_0() {
41710   void * jresult ;
41711   Dali::PinchGestureDetector *result = 0 ;
41712
41713   {
41714     try {
41715       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector();
41716     } catch (std::out_of_range& e) {
41717       {
41718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41719       };
41720     } catch (std::exception& e) {
41721       {
41722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41723       };
41724     } catch (Dali::DaliException e) {
41725       {
41726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41727       };
41728     } catch (...) {
41729       {
41730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41731       };
41732     }
41733   }
41734
41735   jresult = (void *)result;
41736   return jresult;
41737 }
41738
41739
41740 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_New() {
41741   void * jresult ;
41742   Dali::PinchGestureDetector result;
41743
41744   {
41745     try {
41746       result = Dali::PinchGestureDetector::New();
41747     } catch (std::out_of_range& e) {
41748       {
41749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41750       };
41751     } catch (std::exception& e) {
41752       {
41753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41754       };
41755     } catch (Dali::DaliException e) {
41756       {
41757         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41758       };
41759     } catch (...) {
41760       {
41761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41762       };
41763     }
41764   }
41765
41766   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
41767   return jresult;
41768 }
41769
41770
41771 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DownCast(void * jarg1) {
41772   void * jresult ;
41773   Dali::BaseHandle arg1 ;
41774   Dali::BaseHandle *argp1 ;
41775   Dali::PinchGestureDetector result;
41776
41777   argp1 = (Dali::BaseHandle *)jarg1;
41778   if (!argp1) {
41779     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41780     return 0;
41781   }
41782   arg1 = *argp1;
41783   {
41784     try {
41785       result = Dali::PinchGestureDetector::DownCast(arg1);
41786     } catch (std::out_of_range& e) {
41787       {
41788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41789       };
41790     } catch (std::exception& e) {
41791       {
41792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41793       };
41794     } catch (Dali::DaliException e) {
41795       {
41796         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41797       };
41798     } catch (...) {
41799       {
41800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41801       };
41802     }
41803   }
41804
41805   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
41806   return jresult;
41807 }
41808
41809
41810 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetector(void * jarg1) {
41811   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
41812
41813   arg1 = (Dali::PinchGestureDetector *)jarg1;
41814   {
41815     try {
41816       delete arg1;
41817     } catch (std::out_of_range& e) {
41818       {
41819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41820       };
41821     } catch (std::exception& e) {
41822       {
41823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41824       };
41825     } catch (Dali::DaliException e) {
41826       {
41827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41828       };
41829     } catch (...) {
41830       {
41831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41832       };
41833     }
41834   }
41835
41836 }
41837
41838
41839 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_1(void * jarg1) {
41840   void * jresult ;
41841   Dali::PinchGestureDetector *arg1 = 0 ;
41842   Dali::PinchGestureDetector *result = 0 ;
41843
41844   arg1 = (Dali::PinchGestureDetector *)jarg1;
41845   if (!arg1) {
41846     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
41847     return 0;
41848   }
41849   {
41850     try {
41851       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector((Dali::PinchGestureDetector const &)*arg1);
41852     } catch (std::out_of_range& e) {
41853       {
41854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41855       };
41856     } catch (std::exception& e) {
41857       {
41858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41859       };
41860     } catch (Dali::DaliException e) {
41861       {
41862         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41863       };
41864     } catch (...) {
41865       {
41866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41867       };
41868     }
41869   }
41870
41871   jresult = (void *)result;
41872   return jresult;
41873 }
41874
41875
41876 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_Assign(void * jarg1, void * jarg2) {
41877   void * jresult ;
41878   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
41879   Dali::PinchGestureDetector *arg2 = 0 ;
41880   Dali::PinchGestureDetector *result = 0 ;
41881
41882   arg1 = (Dali::PinchGestureDetector *)jarg1;
41883   arg2 = (Dali::PinchGestureDetector *)jarg2;
41884   if (!arg2) {
41885     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
41886     return 0;
41887   }
41888   {
41889     try {
41890       result = (Dali::PinchGestureDetector *) &(arg1)->operator =((Dali::PinchGestureDetector const &)*arg2);
41891     } catch (std::out_of_range& e) {
41892       {
41893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41894       };
41895     } catch (std::exception& e) {
41896       {
41897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41898       };
41899     } catch (Dali::DaliException e) {
41900       {
41901         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41902       };
41903     } catch (...) {
41904       {
41905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41906       };
41907     }
41908   }
41909
41910   jresult = (void *)result;
41911   return jresult;
41912 }
41913
41914
41915 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DetectedSignal(void * jarg1) {
41916   void * jresult ;
41917   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
41918   Dali::PinchGestureDetector::DetectedSignalType *result = 0 ;
41919
41920   arg1 = (Dali::PinchGestureDetector *)jarg1;
41921   {
41922     try {
41923       result = (Dali::PinchGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
41924     } catch (std::out_of_range& e) {
41925       {
41926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41927       };
41928     } catch (std::exception& e) {
41929       {
41930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41931       };
41932     } catch (Dali::DaliException e) {
41933       {
41934         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41935       };
41936     } catch (...) {
41937       {
41938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41939       };
41940     }
41941   }
41942
41943   jresult = (void *)result;
41944   return jresult;
41945 }
41946
41947
41948 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_0(int jarg1) {
41949   void * jresult ;
41950   Dali::Gesture::State arg1 ;
41951   Dali::PinchGesture *result = 0 ;
41952
41953   arg1 = (Dali::Gesture::State)jarg1;
41954   {
41955     try {
41956       result = (Dali::PinchGesture *)new Dali::PinchGesture(arg1);
41957     } catch (std::out_of_range& e) {
41958       {
41959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41960       };
41961     } catch (std::exception& e) {
41962       {
41963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41964       };
41965     } catch (Dali::DaliException e) {
41966       {
41967         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41968       };
41969     } catch (...) {
41970       {
41971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41972       };
41973     }
41974   }
41975
41976   jresult = (void *)result;
41977   return jresult;
41978 }
41979
41980
41981 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_1(void * jarg1) {
41982   void * jresult ;
41983   Dali::PinchGesture *arg1 = 0 ;
41984   Dali::PinchGesture *result = 0 ;
41985
41986   arg1 = (Dali::PinchGesture *)jarg1;
41987   if (!arg1) {
41988     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
41989     return 0;
41990   }
41991   {
41992     try {
41993       result = (Dali::PinchGesture *)new Dali::PinchGesture((Dali::PinchGesture const &)*arg1);
41994     } catch (std::out_of_range& e) {
41995       {
41996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41997       };
41998     } catch (std::exception& e) {
41999       {
42000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42001       };
42002     } catch (Dali::DaliException e) {
42003       {
42004         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42005       };
42006     } catch (...) {
42007       {
42008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42009       };
42010     }
42011   }
42012
42013   jresult = (void *)result;
42014   return jresult;
42015 }
42016
42017
42018 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_Assign(void * jarg1, void * jarg2) {
42019   void * jresult ;
42020   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42021   Dali::PinchGesture *arg2 = 0 ;
42022   Dali::PinchGesture *result = 0 ;
42023
42024   arg1 = (Dali::PinchGesture *)jarg1;
42025   arg2 = (Dali::PinchGesture *)jarg2;
42026   if (!arg2) {
42027     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
42028     return 0;
42029   }
42030   {
42031     try {
42032       result = (Dali::PinchGesture *) &(arg1)->operator =((Dali::PinchGesture const &)*arg2);
42033     } catch (std::out_of_range& e) {
42034       {
42035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42036       };
42037     } catch (std::exception& e) {
42038       {
42039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42040       };
42041     } catch (Dali::DaliException e) {
42042       {
42043         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42044       };
42045     } catch (...) {
42046       {
42047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42048       };
42049     }
42050   }
42051
42052   jresult = (void *)result;
42053   return jresult;
42054 }
42055
42056
42057 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGesture(void * jarg1) {
42058   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42059
42060   arg1 = (Dali::PinchGesture *)jarg1;
42061   {
42062     try {
42063       delete arg1;
42064     } catch (std::out_of_range& e) {
42065       {
42066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42067       };
42068     } catch (std::exception& e) {
42069       {
42070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42071       };
42072     } catch (Dali::DaliException e) {
42073       {
42074         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42075       };
42076     } catch (...) {
42077       {
42078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42079       };
42080     }
42081   }
42082
42083 }
42084
42085
42086 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_scale_set(void * jarg1, float jarg2) {
42087   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42088   float arg2 ;
42089
42090   arg1 = (Dali::PinchGesture *)jarg1;
42091   arg2 = (float)jarg2;
42092   if (arg1) (arg1)->scale = arg2;
42093 }
42094
42095
42096 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_scale_get(void * jarg1) {
42097   float jresult ;
42098   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42099   float result;
42100
42101   arg1 = (Dali::PinchGesture *)jarg1;
42102   result = (float) ((arg1)->scale);
42103   jresult = result;
42104   return jresult;
42105 }
42106
42107
42108 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_speed_set(void * jarg1, float jarg2) {
42109   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42110   float arg2 ;
42111
42112   arg1 = (Dali::PinchGesture *)jarg1;
42113   arg2 = (float)jarg2;
42114   if (arg1) (arg1)->speed = arg2;
42115 }
42116
42117
42118 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_speed_get(void * jarg1) {
42119   float jresult ;
42120   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42121   float result;
42122
42123   arg1 = (Dali::PinchGesture *)jarg1;
42124   result = (float) ((arg1)->speed);
42125   jresult = result;
42126   return jresult;
42127 }
42128
42129
42130 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_set(void * jarg1, void * jarg2) {
42131   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42132   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42133
42134   arg1 = (Dali::PinchGesture *)jarg1;
42135   arg2 = (Dali::Vector2 *)jarg2;
42136   if (arg1) (arg1)->screenCenterPoint = *arg2;
42137 }
42138
42139
42140 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_get(void * jarg1) {
42141   void * jresult ;
42142   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42143   Dali::Vector2 *result = 0 ;
42144
42145   arg1 = (Dali::PinchGesture *)jarg1;
42146   result = (Dali::Vector2 *)& ((arg1)->screenCenterPoint);
42147   jresult = (void *)result;
42148   return jresult;
42149 }
42150
42151
42152 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_set(void * jarg1, void * jarg2) {
42153   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42154   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42155
42156   arg1 = (Dali::PinchGesture *)jarg1;
42157   arg2 = (Dali::Vector2 *)jarg2;
42158   if (arg1) (arg1)->localCenterPoint = *arg2;
42159 }
42160
42161
42162 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_get(void * jarg1) {
42163   void * jresult ;
42164   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42165   Dali::Vector2 *result = 0 ;
42166
42167   arg1 = (Dali::PinchGesture *)jarg1;
42168   result = (Dali::Vector2 *)& ((arg1)->localCenterPoint);
42169   jresult = (void *)result;
42170   return jresult;
42171 }
42172
42173
42174 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_0() {
42175   void * jresult ;
42176   Dali::TapGestureDetector *result = 0 ;
42177
42178   {
42179     try {
42180       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector();
42181     } catch (std::out_of_range& e) {
42182       {
42183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42184       };
42185     } catch (std::exception& e) {
42186       {
42187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42188       };
42189     } catch (Dali::DaliException e) {
42190       {
42191         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42192       };
42193     } catch (...) {
42194       {
42195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42196       };
42197     }
42198   }
42199
42200   jresult = (void *)result;
42201   return jresult;
42202 }
42203
42204
42205 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_0() {
42206   void * jresult ;
42207   Dali::TapGestureDetector result;
42208
42209   {
42210     try {
42211       result = Dali::TapGestureDetector::New();
42212     } catch (std::out_of_range& e) {
42213       {
42214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42215       };
42216     } catch (std::exception& e) {
42217       {
42218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42219       };
42220     } catch (Dali::DaliException e) {
42221       {
42222         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42223       };
42224     } catch (...) {
42225       {
42226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42227       };
42228     }
42229   }
42230
42231   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
42232   return jresult;
42233 }
42234
42235
42236 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_1(unsigned int jarg1) {
42237   void * jresult ;
42238   unsigned int arg1 ;
42239   Dali::TapGestureDetector result;
42240
42241   arg1 = (unsigned int)jarg1;
42242   {
42243     try {
42244       result = Dali::TapGestureDetector::New(arg1);
42245     } catch (std::out_of_range& e) {
42246       {
42247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42248       };
42249     } catch (std::exception& e) {
42250       {
42251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42252       };
42253     } catch (Dali::DaliException e) {
42254       {
42255         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42256       };
42257     } catch (...) {
42258       {
42259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42260       };
42261     }
42262   }
42263
42264   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
42265   return jresult;
42266 }
42267
42268
42269 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DownCast(void * jarg1) {
42270   void * jresult ;
42271   Dali::BaseHandle arg1 ;
42272   Dali::BaseHandle *argp1 ;
42273   Dali::TapGestureDetector result;
42274
42275   argp1 = (Dali::BaseHandle *)jarg1;
42276   if (!argp1) {
42277     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
42278     return 0;
42279   }
42280   arg1 = *argp1;
42281   {
42282     try {
42283       result = Dali::TapGestureDetector::DownCast(arg1);
42284     } catch (std::out_of_range& e) {
42285       {
42286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42287       };
42288     } catch (std::exception& e) {
42289       {
42290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42291       };
42292     } catch (Dali::DaliException e) {
42293       {
42294         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42295       };
42296     } catch (...) {
42297       {
42298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42299       };
42300     }
42301   }
42302
42303   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
42304   return jresult;
42305 }
42306
42307
42308 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetector(void * jarg1) {
42309   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42310
42311   arg1 = (Dali::TapGestureDetector *)jarg1;
42312   {
42313     try {
42314       delete arg1;
42315     } catch (std::out_of_range& e) {
42316       {
42317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42318       };
42319     } catch (std::exception& e) {
42320       {
42321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42322       };
42323     } catch (Dali::DaliException e) {
42324       {
42325         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42326       };
42327     } catch (...) {
42328       {
42329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42330       };
42331     }
42332   }
42333
42334 }
42335
42336
42337 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_1(void * jarg1) {
42338   void * jresult ;
42339   Dali::TapGestureDetector *arg1 = 0 ;
42340   Dali::TapGestureDetector *result = 0 ;
42341
42342   arg1 = (Dali::TapGestureDetector *)jarg1;
42343   if (!arg1) {
42344     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
42345     return 0;
42346   }
42347   {
42348     try {
42349       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector((Dali::TapGestureDetector const &)*arg1);
42350     } catch (std::out_of_range& e) {
42351       {
42352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42353       };
42354     } catch (std::exception& e) {
42355       {
42356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42357       };
42358     } catch (Dali::DaliException e) {
42359       {
42360         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42361       };
42362     } catch (...) {
42363       {
42364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42365       };
42366     }
42367   }
42368
42369   jresult = (void *)result;
42370   return jresult;
42371 }
42372
42373
42374 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_Assign(void * jarg1, void * jarg2) {
42375   void * jresult ;
42376   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42377   Dali::TapGestureDetector *arg2 = 0 ;
42378   Dali::TapGestureDetector *result = 0 ;
42379
42380   arg1 = (Dali::TapGestureDetector *)jarg1;
42381   arg2 = (Dali::TapGestureDetector *)jarg2;
42382   if (!arg2) {
42383     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
42384     return 0;
42385   }
42386   {
42387     try {
42388       result = (Dali::TapGestureDetector *) &(arg1)->operator =((Dali::TapGestureDetector const &)*arg2);
42389     } catch (std::out_of_range& e) {
42390       {
42391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42392       };
42393     } catch (std::exception& e) {
42394       {
42395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42396       };
42397     } catch (Dali::DaliException e) {
42398       {
42399         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42400       };
42401     } catch (...) {
42402       {
42403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42404       };
42405     }
42406   }
42407
42408   jresult = (void *)result;
42409   return jresult;
42410 }
42411
42412
42413 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMinimumTapsRequired(void * jarg1, unsigned int jarg2) {
42414   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42415   unsigned int arg2 ;
42416
42417   arg1 = (Dali::TapGestureDetector *)jarg1;
42418   arg2 = (unsigned int)jarg2;
42419   {
42420     try {
42421       (arg1)->SetMinimumTapsRequired(arg2);
42422     } catch (std::out_of_range& e) {
42423       {
42424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42425       };
42426     } catch (std::exception& e) {
42427       {
42428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42429       };
42430     } catch (Dali::DaliException e) {
42431       {
42432         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42433       };
42434     } catch (...) {
42435       {
42436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42437       };
42438     }
42439   }
42440
42441 }
42442
42443
42444 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMaximumTapsRequired(void * jarg1, unsigned int jarg2) {
42445   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42446   unsigned int arg2 ;
42447
42448   arg1 = (Dali::TapGestureDetector *)jarg1;
42449   arg2 = (unsigned int)jarg2;
42450   {
42451     try {
42452       (arg1)->SetMaximumTapsRequired(arg2);
42453     } catch (std::out_of_range& e) {
42454       {
42455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42456       };
42457     } catch (std::exception& e) {
42458       {
42459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42460       };
42461     } catch (Dali::DaliException e) {
42462       {
42463         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42464       };
42465     } catch (...) {
42466       {
42467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42468       };
42469     }
42470   }
42471
42472 }
42473
42474
42475 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMinimumTapsRequired(void * jarg1) {
42476   unsigned int jresult ;
42477   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42478   unsigned int result;
42479
42480   arg1 = (Dali::TapGestureDetector *)jarg1;
42481   {
42482     try {
42483       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMinimumTapsRequired();
42484     } catch (std::out_of_range& e) {
42485       {
42486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42487       };
42488     } catch (std::exception& e) {
42489       {
42490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42491       };
42492     } catch (Dali::DaliException e) {
42493       {
42494         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42495       };
42496     } catch (...) {
42497       {
42498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42499       };
42500     }
42501   }
42502
42503   jresult = result;
42504   return jresult;
42505 }
42506
42507
42508 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMaximumTapsRequired(void * jarg1) {
42509   unsigned int jresult ;
42510   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42511   unsigned int result;
42512
42513   arg1 = (Dali::TapGestureDetector *)jarg1;
42514   {
42515     try {
42516       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMaximumTapsRequired();
42517     } catch (std::out_of_range& e) {
42518       {
42519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42520       };
42521     } catch (std::exception& e) {
42522       {
42523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42524       };
42525     } catch (Dali::DaliException e) {
42526       {
42527         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42528       };
42529     } catch (...) {
42530       {
42531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42532       };
42533     }
42534   }
42535
42536   jresult = result;
42537   return jresult;
42538 }
42539
42540
42541 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DetectedSignal(void * jarg1) {
42542   void * jresult ;
42543   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42544   Dali::TapGestureDetector::DetectedSignalType *result = 0 ;
42545
42546   arg1 = (Dali::TapGestureDetector *)jarg1;
42547   {
42548     try {
42549       result = (Dali::TapGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
42550     } catch (std::out_of_range& e) {
42551       {
42552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42553       };
42554     } catch (std::exception& e) {
42555       {
42556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42557       };
42558     } catch (Dali::DaliException e) {
42559       {
42560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42561       };
42562     } catch (...) {
42563       {
42564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42565       };
42566     }
42567   }
42568
42569   jresult = (void *)result;
42570   return jresult;
42571 }
42572
42573
42574 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_0() {
42575   void * jresult ;
42576   Dali::TapGesture *result = 0 ;
42577
42578   {
42579     try {
42580       result = (Dali::TapGesture *)new Dali::TapGesture();
42581     } catch (std::out_of_range& e) {
42582       {
42583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42584       };
42585     } catch (std::exception& e) {
42586       {
42587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42588       };
42589     } catch (Dali::DaliException e) {
42590       {
42591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42592       };
42593     } catch (...) {
42594       {
42595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42596       };
42597     }
42598   }
42599
42600   jresult = (void *)result;
42601   return jresult;
42602 }
42603
42604
42605 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_1(void * jarg1) {
42606   void * jresult ;
42607   Dali::TapGesture *arg1 = 0 ;
42608   Dali::TapGesture *result = 0 ;
42609
42610   arg1 = (Dali::TapGesture *)jarg1;
42611   if (!arg1) {
42612     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
42613     return 0;
42614   }
42615   {
42616     try {
42617       result = (Dali::TapGesture *)new Dali::TapGesture((Dali::TapGesture const &)*arg1);
42618     } catch (std::out_of_range& e) {
42619       {
42620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42621       };
42622     } catch (std::exception& e) {
42623       {
42624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42625       };
42626     } catch (Dali::DaliException e) {
42627       {
42628         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42629       };
42630     } catch (...) {
42631       {
42632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42633       };
42634     }
42635   }
42636
42637   jresult = (void *)result;
42638   return jresult;
42639 }
42640
42641
42642 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_Assign(void * jarg1, void * jarg2) {
42643   void * jresult ;
42644   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42645   Dali::TapGesture *arg2 = 0 ;
42646   Dali::TapGesture *result = 0 ;
42647
42648   arg1 = (Dali::TapGesture *)jarg1;
42649   arg2 = (Dali::TapGesture *)jarg2;
42650   if (!arg2) {
42651     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
42652     return 0;
42653   }
42654   {
42655     try {
42656       result = (Dali::TapGesture *) &(arg1)->operator =((Dali::TapGesture const &)*arg2);
42657     } catch (std::out_of_range& e) {
42658       {
42659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42660       };
42661     } catch (std::exception& e) {
42662       {
42663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42664       };
42665     } catch (Dali::DaliException e) {
42666       {
42667         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42668       };
42669     } catch (...) {
42670       {
42671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42672       };
42673     }
42674   }
42675
42676   jresult = (void *)result;
42677   return jresult;
42678 }
42679
42680
42681 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGesture(void * jarg1) {
42682   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42683
42684   arg1 = (Dali::TapGesture *)jarg1;
42685   {
42686     try {
42687       delete arg1;
42688     } catch (std::out_of_range& e) {
42689       {
42690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42691       };
42692     } catch (std::exception& e) {
42693       {
42694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42695       };
42696     } catch (Dali::DaliException e) {
42697       {
42698         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42699       };
42700     } catch (...) {
42701       {
42702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42703       };
42704     }
42705   }
42706
42707 }
42708
42709
42710 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_set(void * jarg1, unsigned int jarg2) {
42711   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42712   unsigned int arg2 ;
42713
42714   arg1 = (Dali::TapGesture *)jarg1;
42715   arg2 = (unsigned int)jarg2;
42716   if (arg1) (arg1)->numberOfTaps = arg2;
42717 }
42718
42719
42720 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_get(void * jarg1) {
42721   unsigned int jresult ;
42722   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42723   unsigned int result;
42724
42725   arg1 = (Dali::TapGesture *)jarg1;
42726   result = (unsigned int) ((arg1)->numberOfTaps);
42727   jresult = result;
42728   return jresult;
42729 }
42730
42731
42732 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
42733   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42734   unsigned int arg2 ;
42735
42736   arg1 = (Dali::TapGesture *)jarg1;
42737   arg2 = (unsigned int)jarg2;
42738   if (arg1) (arg1)->numberOfTouches = arg2;
42739 }
42740
42741
42742 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_get(void * jarg1) {
42743   unsigned int jresult ;
42744   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42745   unsigned int result;
42746
42747   arg1 = (Dali::TapGesture *)jarg1;
42748   result = (unsigned int) ((arg1)->numberOfTouches);
42749   jresult = result;
42750   return jresult;
42751 }
42752
42753
42754 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_set(void * jarg1, void * jarg2) {
42755   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42756   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42757
42758   arg1 = (Dali::TapGesture *)jarg1;
42759   arg2 = (Dali::Vector2 *)jarg2;
42760   if (arg1) (arg1)->screenPoint = *arg2;
42761 }
42762
42763
42764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_get(void * jarg1) {
42765   void * jresult ;
42766   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42767   Dali::Vector2 *result = 0 ;
42768
42769   arg1 = (Dali::TapGesture *)jarg1;
42770   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
42771   jresult = (void *)result;
42772   return jresult;
42773 }
42774
42775
42776 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_set(void * jarg1, void * jarg2) {
42777   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42778   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42779
42780   arg1 = (Dali::TapGesture *)jarg1;
42781   arg2 = (Dali::Vector2 *)jarg2;
42782   if (arg1) (arg1)->localPoint = *arg2;
42783 }
42784
42785
42786 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_get(void * jarg1) {
42787   void * jresult ;
42788   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42789   Dali::Vector2 *result = 0 ;
42790
42791   arg1 = (Dali::TapGesture *)jarg1;
42792   result = (Dali::Vector2 *)& ((arg1)->localPoint);
42793   jresult = (void *)result;
42794   return jresult;
42795 }
42796
42797
42798 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_0() {
42799   void * jresult ;
42800   Dali::AlphaFunction *result = 0 ;
42801
42802   {
42803     try {
42804       result = (Dali::AlphaFunction *)new Dali::AlphaFunction();
42805     } catch (std::out_of_range& e) {
42806       {
42807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42808       };
42809     } catch (std::exception& e) {
42810       {
42811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42812       };
42813     } catch (Dali::DaliException e) {
42814       {
42815         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42816       };
42817     } catch (...) {
42818       {
42819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42820       };
42821     }
42822   }
42823
42824   jresult = (void *)result;
42825   return jresult;
42826 }
42827
42828
42829 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_1(int jarg1) {
42830   void * jresult ;
42831   Dali::AlphaFunction::BuiltinFunction arg1 ;
42832   Dali::AlphaFunction *result = 0 ;
42833
42834   arg1 = (Dali::AlphaFunction::BuiltinFunction)jarg1;
42835   {
42836     try {
42837       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
42838     } catch (std::out_of_range& e) {
42839       {
42840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42841       };
42842     } catch (std::exception& e) {
42843       {
42844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42845       };
42846     } catch (Dali::DaliException e) {
42847       {
42848         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42849       };
42850     } catch (...) {
42851       {
42852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42853       };
42854     }
42855   }
42856
42857   jresult = (void *)result;
42858   return jresult;
42859 }
42860
42861
42862 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_2(void * jarg1) {
42863   void * jresult ;
42864   Dali::AlphaFunctionPrototype arg1 = (Dali::AlphaFunctionPrototype) 0 ;
42865   Dali::AlphaFunction *result = 0 ;
42866
42867   arg1 = (Dali::AlphaFunctionPrototype)jarg1;
42868   {
42869     try {
42870       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
42871     } catch (std::out_of_range& e) {
42872       {
42873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42874       };
42875     } catch (std::exception& e) {
42876       {
42877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42878       };
42879     } catch (Dali::DaliException e) {
42880       {
42881         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42882       };
42883     } catch (...) {
42884       {
42885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42886       };
42887     }
42888   }
42889
42890   jresult = (void *)result;
42891   return jresult;
42892 }
42893
42894
42895 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_3(void * jarg1, void * jarg2) {
42896   void * jresult ;
42897   Dali::Vector2 *arg1 = 0 ;
42898   Dali::Vector2 *arg2 = 0 ;
42899   Dali::AlphaFunction *result = 0 ;
42900
42901   arg1 = (Dali::Vector2 *)jarg1;
42902   if (!arg1) {
42903     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
42904     return 0;
42905   }
42906   arg2 = (Dali::Vector2 *)jarg2;
42907   if (!arg2) {
42908     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
42909     return 0;
42910   }
42911   {
42912     try {
42913       result = (Dali::AlphaFunction *)new Dali::AlphaFunction((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
42914     } catch (std::out_of_range& e) {
42915       {
42916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42917       };
42918     } catch (std::exception& e) {
42919       {
42920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42921       };
42922     } catch (Dali::DaliException e) {
42923       {
42924         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42925       };
42926     } catch (...) {
42927       {
42928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42929       };
42930     }
42931   }
42932
42933   jresult = (void *)result;
42934   return jresult;
42935 }
42936
42937
42938 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBezierControlPoints(void * jarg1) {
42939   void * jresult ;
42940   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
42941   Dali::Vector4 result;
42942
42943   arg1 = (Dali::AlphaFunction *)jarg1;
42944   {
42945     try {
42946       result = ((Dali::AlphaFunction const *)arg1)->GetBezierControlPoints();
42947     } catch (std::out_of_range& e) {
42948       {
42949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42950       };
42951     } catch (std::exception& e) {
42952       {
42953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42954       };
42955     } catch (Dali::DaliException e) {
42956       {
42957         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42958       };
42959     } catch (...) {
42960       {
42961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42962       };
42963     }
42964   }
42965
42966   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
42967   return jresult;
42968 }
42969
42970
42971 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetCustomFunction(void * jarg1) {
42972   void * jresult ;
42973   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
42974   Dali::AlphaFunctionPrototype result;
42975
42976   arg1 = (Dali::AlphaFunction *)jarg1;
42977   {
42978     try {
42979       result = (Dali::AlphaFunctionPrototype)((Dali::AlphaFunction const *)arg1)->GetCustomFunction();
42980     } catch (std::out_of_range& e) {
42981       {
42982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42983       };
42984     } catch (std::exception& e) {
42985       {
42986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42987       };
42988     } catch (Dali::DaliException e) {
42989       {
42990         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42991       };
42992     } catch (...) {
42993       {
42994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42995       };
42996     }
42997   }
42998
42999   jresult = (void *)result;
43000   return jresult;
43001 }
43002
43003
43004 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBuiltinFunction(void * jarg1) {
43005   int jresult ;
43006   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
43007   Dali::AlphaFunction::BuiltinFunction result;
43008
43009   arg1 = (Dali::AlphaFunction *)jarg1;
43010   {
43011     try {
43012       result = (Dali::AlphaFunction::BuiltinFunction)((Dali::AlphaFunction const *)arg1)->GetBuiltinFunction();
43013     } catch (std::out_of_range& e) {
43014       {
43015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43016       };
43017     } catch (std::exception& e) {
43018       {
43019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43020       };
43021     } catch (Dali::DaliException e) {
43022       {
43023         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43024       };
43025     } catch (...) {
43026       {
43027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43028       };
43029     }
43030   }
43031
43032   jresult = (int)result;
43033   return jresult;
43034 }
43035
43036
43037 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetMode(void * jarg1) {
43038   int jresult ;
43039   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
43040   Dali::AlphaFunction::Mode result;
43041
43042   arg1 = (Dali::AlphaFunction *)jarg1;
43043   {
43044     try {
43045       result = (Dali::AlphaFunction::Mode)((Dali::AlphaFunction const *)arg1)->GetMode();
43046     } catch (std::out_of_range& e) {
43047       {
43048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43049       };
43050     } catch (std::exception& e) {
43051       {
43052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43053       };
43054     } catch (Dali::DaliException e) {
43055       {
43056         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43057       };
43058     } catch (...) {
43059       {
43060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43061       };
43062     }
43063   }
43064
43065   jresult = (int)result;
43066   return jresult;
43067 }
43068
43069
43070 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AlphaFunction(void * jarg1) {
43071   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
43072
43073   arg1 = (Dali::AlphaFunction *)jarg1;
43074   {
43075     try {
43076       delete arg1;
43077     } catch (std::out_of_range& e) {
43078       {
43079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43080       };
43081     } catch (std::exception& e) {
43082       {
43083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43084       };
43085     } catch (Dali::DaliException e) {
43086       {
43087         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43088       };
43089     } catch (...) {
43090       {
43091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43092       };
43093     }
43094   }
43095
43096 }
43097
43098
43099 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_New() {
43100   void * jresult ;
43101   Dali::KeyFrames result;
43102
43103   {
43104     try {
43105       result = Dali::KeyFrames::New();
43106     } catch (std::out_of_range& e) {
43107       {
43108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43109       };
43110     } catch (std::exception& e) {
43111       {
43112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43113       };
43114     } catch (Dali::DaliException e) {
43115       {
43116         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43117       };
43118     } catch (...) {
43119       {
43120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43121       };
43122     }
43123   }
43124
43125   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
43126   return jresult;
43127 }
43128
43129
43130 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_DownCast(void * jarg1) {
43131   void * jresult ;
43132   Dali::BaseHandle arg1 ;
43133   Dali::BaseHandle *argp1 ;
43134   Dali::KeyFrames result;
43135
43136   argp1 = (Dali::BaseHandle *)jarg1;
43137   if (!argp1) {
43138     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43139     return 0;
43140   }
43141   arg1 = *argp1;
43142   {
43143     try {
43144       result = Dali::KeyFrames::DownCast(arg1);
43145     } catch (std::out_of_range& e) {
43146       {
43147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43148       };
43149     } catch (std::exception& e) {
43150       {
43151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43152       };
43153     } catch (Dali::DaliException e) {
43154       {
43155         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43156       };
43157     } catch (...) {
43158       {
43159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43160       };
43161     }
43162   }
43163
43164   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
43165   return jresult;
43166 }
43167
43168
43169 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_0() {
43170   void * jresult ;
43171   Dali::KeyFrames *result = 0 ;
43172
43173   {
43174     try {
43175       result = (Dali::KeyFrames *)new Dali::KeyFrames();
43176     } catch (std::out_of_range& e) {
43177       {
43178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43179       };
43180     } catch (std::exception& e) {
43181       {
43182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43183       };
43184     } catch (Dali::DaliException e) {
43185       {
43186         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43187       };
43188     } catch (...) {
43189       {
43190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43191       };
43192     }
43193   }
43194
43195   jresult = (void *)result;
43196   return jresult;
43197 }
43198
43199
43200 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyFrames(void * jarg1) {
43201   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43202
43203   arg1 = (Dali::KeyFrames *)jarg1;
43204   {
43205     try {
43206       delete arg1;
43207     } catch (std::out_of_range& e) {
43208       {
43209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43210       };
43211     } catch (std::exception& e) {
43212       {
43213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43214       };
43215     } catch (Dali::DaliException e) {
43216       {
43217         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43218       };
43219     } catch (...) {
43220       {
43221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43222       };
43223     }
43224   }
43225
43226 }
43227
43228
43229 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_1(void * jarg1) {
43230   void * jresult ;
43231   Dali::KeyFrames *arg1 = 0 ;
43232   Dali::KeyFrames *result = 0 ;
43233
43234   arg1 = (Dali::KeyFrames *)jarg1;
43235   if (!arg1) {
43236     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
43237     return 0;
43238   }
43239   {
43240     try {
43241       result = (Dali::KeyFrames *)new Dali::KeyFrames((Dali::KeyFrames const &)*arg1);
43242     } catch (std::out_of_range& e) {
43243       {
43244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43245       };
43246     } catch (std::exception& e) {
43247       {
43248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43249       };
43250     } catch (Dali::DaliException e) {
43251       {
43252         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43253       };
43254     } catch (...) {
43255       {
43256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43257       };
43258     }
43259   }
43260
43261   jresult = (void *)result;
43262   return jresult;
43263 }
43264
43265
43266 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_Assign(void * jarg1, void * jarg2) {
43267   void * jresult ;
43268   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43269   Dali::KeyFrames *arg2 = 0 ;
43270   Dali::KeyFrames *result = 0 ;
43271
43272   arg1 = (Dali::KeyFrames *)jarg1;
43273   arg2 = (Dali::KeyFrames *)jarg2;
43274   if (!arg2) {
43275     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
43276     return 0;
43277   }
43278   {
43279     try {
43280       result = (Dali::KeyFrames *) &(arg1)->operator =((Dali::KeyFrames const &)*arg2);
43281     } catch (std::out_of_range& e) {
43282       {
43283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43284       };
43285     } catch (std::exception& e) {
43286       {
43287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43288       };
43289     } catch (Dali::DaliException e) {
43290       {
43291         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43292       };
43293     } catch (...) {
43294       {
43295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43296       };
43297     }
43298   }
43299
43300   jresult = (void *)result;
43301   return jresult;
43302 }
43303
43304
43305 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_KeyFrames_GetType(void * jarg1) {
43306   int jresult ;
43307   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43308   Dali::Property::Type result;
43309
43310   arg1 = (Dali::KeyFrames *)jarg1;
43311   {
43312     try {
43313       result = (Dali::Property::Type)((Dali::KeyFrames const *)arg1)->GetType();
43314     } catch (std::out_of_range& e) {
43315       {
43316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43317       };
43318     } catch (std::exception& e) {
43319       {
43320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43321       };
43322     } catch (Dali::DaliException e) {
43323       {
43324         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43325       };
43326     } catch (...) {
43327       {
43328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43329       };
43330     }
43331   }
43332
43333   jresult = (int)result;
43334   return jresult;
43335 }
43336
43337
43338 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_0(void * jarg1, float jarg2, void * jarg3) {
43339   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43340   float arg2 ;
43341   Dali::Property::Value arg3 ;
43342   Dali::Property::Value *argp3 ;
43343
43344   arg1 = (Dali::KeyFrames *)jarg1;
43345   arg2 = (float)jarg2;
43346   argp3 = (Dali::Property::Value *)jarg3;
43347   if (!argp3) {
43348     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
43349     return ;
43350   }
43351   arg3 = *argp3;
43352   {
43353     try {
43354       (arg1)->Add(arg2,arg3);
43355     } catch (std::out_of_range& e) {
43356       {
43357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43358       };
43359     } catch (std::exception& e) {
43360       {
43361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43362       };
43363     } catch (Dali::DaliException e) {
43364       {
43365         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43366       };
43367     } catch (...) {
43368       {
43369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43370       };
43371     }
43372   }
43373
43374 }
43375
43376
43377 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_1(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
43378   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43379   float arg2 ;
43380   Dali::Property::Value arg3 ;
43381   Dali::AlphaFunction arg4 ;
43382   Dali::Property::Value *argp3 ;
43383   Dali::AlphaFunction *argp4 ;
43384
43385   arg1 = (Dali::KeyFrames *)jarg1;
43386   arg2 = (float)jarg2;
43387   argp3 = (Dali::Property::Value *)jarg3;
43388   if (!argp3) {
43389     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
43390     return ;
43391   }
43392   arg3 = *argp3;
43393   argp4 = (Dali::AlphaFunction *)jarg4;
43394   if (!argp4) {
43395     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
43396     return ;
43397   }
43398   arg4 = *argp4;
43399   {
43400     try {
43401       (arg1)->Add(arg2,arg3,arg4);
43402     } catch (std::out_of_range& e) {
43403       {
43404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43405       };
43406     } catch (std::exception& e) {
43407       {
43408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43409       };
43410     } catch (Dali::DaliException e) {
43411       {
43412         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43413       };
43414     } catch (...) {
43415       {
43416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43417       };
43418     }
43419   }
43420
43421 }
43422
43423
43424 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_POINTS_get() {
43425   int jresult ;
43426   int result;
43427
43428   result = (int)Dali::Path::Property::POINTS;
43429   jresult = (int)result;
43430   return jresult;
43431 }
43432
43433
43434 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_CONTROL_POINTS_get() {
43435   int jresult ;
43436   int result;
43437
43438   result = (int)Dali::Path::Property::CONTROL_POINTS;
43439   jresult = (int)result;
43440   return jresult;
43441 }
43442
43443
43444 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path_Property() {
43445   void * jresult ;
43446   Dali::Path::Property *result = 0 ;
43447
43448   {
43449     try {
43450       result = (Dali::Path::Property *)new Dali::Path::Property();
43451     } catch (std::out_of_range& e) {
43452       {
43453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43454       };
43455     } catch (std::exception& e) {
43456       {
43457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43458       };
43459     } catch (Dali::DaliException e) {
43460       {
43461         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43462       };
43463     } catch (...) {
43464       {
43465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43466       };
43467     }
43468   }
43469
43470   jresult = (void *)result;
43471   return jresult;
43472 }
43473
43474
43475 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path_Property(void * jarg1) {
43476   Dali::Path::Property *arg1 = (Dali::Path::Property *) 0 ;
43477
43478   arg1 = (Dali::Path::Property *)jarg1;
43479   {
43480     try {
43481       delete arg1;
43482     } catch (std::out_of_range& e) {
43483       {
43484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43485       };
43486     } catch (std::exception& e) {
43487       {
43488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43489       };
43490     } catch (Dali::DaliException e) {
43491       {
43492         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43493       };
43494     } catch (...) {
43495       {
43496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43497       };
43498     }
43499   }
43500
43501 }
43502
43503
43504 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_New() {
43505   void * jresult ;
43506   Dali::Path result;
43507
43508   {
43509     try {
43510       result = Dali::Path::New();
43511     } catch (std::out_of_range& e) {
43512       {
43513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43514       };
43515     } catch (std::exception& e) {
43516       {
43517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43518       };
43519     } catch (Dali::DaliException e) {
43520       {
43521         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43522       };
43523     } catch (...) {
43524       {
43525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43526       };
43527     }
43528   }
43529
43530   jresult = new Dali::Path((const Dali::Path &)result);
43531   return jresult;
43532 }
43533
43534
43535 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_DownCast(void * jarg1) {
43536   void * jresult ;
43537   Dali::BaseHandle arg1 ;
43538   Dali::BaseHandle *argp1 ;
43539   Dali::Path result;
43540
43541   argp1 = (Dali::BaseHandle *)jarg1;
43542   if (!argp1) {
43543     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43544     return 0;
43545   }
43546   arg1 = *argp1;
43547   {
43548     try {
43549       result = Dali::Path::DownCast(arg1);
43550     } catch (std::out_of_range& e) {
43551       {
43552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43553       };
43554     } catch (std::exception& e) {
43555       {
43556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43557       };
43558     } catch (Dali::DaliException e) {
43559       {
43560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43561       };
43562     } catch (...) {
43563       {
43564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43565       };
43566     }
43567   }
43568
43569   jresult = new Dali::Path((const Dali::Path &)result);
43570   return jresult;
43571 }
43572
43573
43574 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_0() {
43575   void * jresult ;
43576   Dali::Path *result = 0 ;
43577
43578   {
43579     try {
43580       result = (Dali::Path *)new Dali::Path();
43581     } catch (std::out_of_range& e) {
43582       {
43583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43584       };
43585     } catch (std::exception& e) {
43586       {
43587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43588       };
43589     } catch (Dali::DaliException e) {
43590       {
43591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43592       };
43593     } catch (...) {
43594       {
43595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43596       };
43597     }
43598   }
43599
43600   jresult = (void *)result;
43601   return jresult;
43602 }
43603
43604
43605 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path(void * jarg1) {
43606   Dali::Path *arg1 = (Dali::Path *) 0 ;
43607
43608   arg1 = (Dali::Path *)jarg1;
43609   {
43610     try {
43611       delete arg1;
43612     } catch (std::out_of_range& e) {
43613       {
43614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43615       };
43616     } catch (std::exception& e) {
43617       {
43618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43619       };
43620     } catch (Dali::DaliException e) {
43621       {
43622         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43623       };
43624     } catch (...) {
43625       {
43626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43627       };
43628     }
43629   }
43630
43631 }
43632
43633
43634 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_1(void * jarg1) {
43635   void * jresult ;
43636   Dali::Path *arg1 = 0 ;
43637   Dali::Path *result = 0 ;
43638
43639   arg1 = (Dali::Path *)jarg1;
43640   if (!arg1) {
43641     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
43642     return 0;
43643   }
43644   {
43645     try {
43646       result = (Dali::Path *)new Dali::Path((Dali::Path const &)*arg1);
43647     } catch (std::out_of_range& e) {
43648       {
43649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43650       };
43651     } catch (std::exception& e) {
43652       {
43653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43654       };
43655     } catch (Dali::DaliException e) {
43656       {
43657         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43658       };
43659     } catch (...) {
43660       {
43661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43662       };
43663     }
43664   }
43665
43666   jresult = (void *)result;
43667   return jresult;
43668 }
43669
43670
43671 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_Assign(void * jarg1, void * jarg2) {
43672   void * jresult ;
43673   Dali::Path *arg1 = (Dali::Path *) 0 ;
43674   Dali::Path *arg2 = 0 ;
43675   Dali::Path *result = 0 ;
43676
43677   arg1 = (Dali::Path *)jarg1;
43678   arg2 = (Dali::Path *)jarg2;
43679   if (!arg2) {
43680     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
43681     return 0;
43682   }
43683   {
43684     try {
43685       result = (Dali::Path *) &(arg1)->operator =((Dali::Path const &)*arg2);
43686     } catch (std::out_of_range& e) {
43687       {
43688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43689       };
43690     } catch (std::exception& e) {
43691       {
43692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43693       };
43694     } catch (Dali::DaliException e) {
43695       {
43696         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43697       };
43698     } catch (...) {
43699       {
43700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43701       };
43702     }
43703   }
43704
43705   jresult = (void *)result;
43706   return jresult;
43707 }
43708
43709
43710 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddPoint(void * jarg1, void * jarg2) {
43711   Dali::Path *arg1 = (Dali::Path *) 0 ;
43712   Dali::Vector3 *arg2 = 0 ;
43713
43714   arg1 = (Dali::Path *)jarg1;
43715   arg2 = (Dali::Vector3 *)jarg2;
43716   if (!arg2) {
43717     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
43718     return ;
43719   }
43720   {
43721     try {
43722       (arg1)->AddPoint((Dali::Vector3 const &)*arg2);
43723     } catch (std::out_of_range& e) {
43724       {
43725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43726       };
43727     } catch (std::exception& e) {
43728       {
43729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43730       };
43731     } catch (Dali::DaliException e) {
43732       {
43733         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43734       };
43735     } catch (...) {
43736       {
43737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43738       };
43739     }
43740   }
43741
43742 }
43743
43744
43745 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddControlPoint(void * jarg1, void * jarg2) {
43746   Dali::Path *arg1 = (Dali::Path *) 0 ;
43747   Dali::Vector3 *arg2 = 0 ;
43748
43749   arg1 = (Dali::Path *)jarg1;
43750   arg2 = (Dali::Vector3 *)jarg2;
43751   if (!arg2) {
43752     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
43753     return ;
43754   }
43755   {
43756     try {
43757       (arg1)->AddControlPoint((Dali::Vector3 const &)*arg2);
43758     } catch (std::out_of_range& e) {
43759       {
43760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43761       };
43762     } catch (std::exception& e) {
43763       {
43764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43765       };
43766     } catch (Dali::DaliException e) {
43767       {
43768         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43769       };
43770     } catch (...) {
43771       {
43772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43773       };
43774     }
43775   }
43776
43777 }
43778
43779
43780 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_GenerateControlPoints(void * jarg1, float jarg2) {
43781   Dali::Path *arg1 = (Dali::Path *) 0 ;
43782   float arg2 ;
43783
43784   arg1 = (Dali::Path *)jarg1;
43785   arg2 = (float)jarg2;
43786   {
43787     try {
43788       (arg1)->GenerateControlPoints(arg2);
43789     } catch (std::out_of_range& e) {
43790       {
43791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43792       };
43793     } catch (std::exception& e) {
43794       {
43795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43796       };
43797     } catch (Dali::DaliException e) {
43798       {
43799         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43800       };
43801     } catch (...) {
43802       {
43803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43804       };
43805     }
43806   }
43807
43808 }
43809
43810
43811 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_Sample(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
43812   Dali::Path *arg1 = (Dali::Path *) 0 ;
43813   float arg2 ;
43814   Dali::Vector3 *arg3 = 0 ;
43815   Dali::Vector3 *arg4 = 0 ;
43816
43817   arg1 = (Dali::Path *)jarg1;
43818   arg2 = (float)jarg2;
43819   arg3 = (Dali::Vector3 *)jarg3;
43820   if (!arg3) {
43821     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
43822     return ;
43823   }
43824   arg4 = (Dali::Vector3 *)jarg4;
43825   if (!arg4) {
43826     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
43827     return ;
43828   }
43829   {
43830     try {
43831       ((Dali::Path const *)arg1)->Sample(arg2,*arg3,*arg4);
43832     } catch (std::out_of_range& e) {
43833       {
43834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43835       };
43836     } catch (std::exception& e) {
43837       {
43838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43839       };
43840     } catch (Dali::DaliException e) {
43841       {
43842         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43843       };
43844     } catch (...) {
43845       {
43846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43847       };
43848     }
43849   }
43850
43851 }
43852
43853
43854 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetPoint(void * jarg1, unsigned long jarg2) {
43855   void * jresult ;
43856   Dali::Path *arg1 = (Dali::Path *) 0 ;
43857   size_t arg2 ;
43858   Dali::Vector3 *result = 0 ;
43859
43860   arg1 = (Dali::Path *)jarg1;
43861   arg2 = (size_t)jarg2;
43862   {
43863     try {
43864       result = (Dali::Vector3 *) &(arg1)->GetPoint(arg2);
43865     } catch (std::out_of_range& e) {
43866       {
43867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43868       };
43869     } catch (std::exception& e) {
43870       {
43871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43872       };
43873     } catch (Dali::DaliException e) {
43874       {
43875         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43876       };
43877     } catch (...) {
43878       {
43879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43880       };
43881     }
43882   }
43883
43884   jresult = (void *)result;
43885   return jresult;
43886 }
43887
43888
43889 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetControlPoint(void * jarg1, unsigned long jarg2) {
43890   void * jresult ;
43891   Dali::Path *arg1 = (Dali::Path *) 0 ;
43892   size_t arg2 ;
43893   Dali::Vector3 *result = 0 ;
43894
43895   arg1 = (Dali::Path *)jarg1;
43896   arg2 = (size_t)jarg2;
43897   {
43898     try {
43899       result = (Dali::Vector3 *) &(arg1)->GetControlPoint(arg2);
43900     } catch (std::out_of_range& e) {
43901       {
43902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43903       };
43904     } catch (std::exception& e) {
43905       {
43906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43907       };
43908     } catch (Dali::DaliException e) {
43909       {
43910         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43911       };
43912     } catch (...) {
43913       {
43914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43915       };
43916     }
43917   }
43918
43919   jresult = (void *)result;
43920   return jresult;
43921 }
43922
43923
43924 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Path_GetPointCount(void * jarg1) {
43925   unsigned long jresult ;
43926   Dali::Path *arg1 = (Dali::Path *) 0 ;
43927   size_t result;
43928
43929   arg1 = (Dali::Path *)jarg1;
43930   {
43931     try {
43932       result = ((Dali::Path const *)arg1)->GetPointCount();
43933     } catch (std::out_of_range& e) {
43934       {
43935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43936       };
43937     } catch (std::exception& e) {
43938       {
43939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43940       };
43941     } catch (Dali::DaliException e) {
43942       {
43943         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43944       };
43945     } catch (...) {
43946       {
43947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43948       };
43949     }
43950   }
43951
43952   jresult = (unsigned long)result;
43953   return jresult;
43954 }
43955
43956
43957 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_0(float jarg1) {
43958   void * jresult ;
43959   float arg1 ;
43960   Dali::TimePeriod *result = 0 ;
43961
43962   arg1 = (float)jarg1;
43963   {
43964     try {
43965       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1);
43966     } catch (std::out_of_range& e) {
43967       {
43968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43969       };
43970     } catch (std::exception& e) {
43971       {
43972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43973       };
43974     } catch (Dali::DaliException e) {
43975       {
43976         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43977       };
43978     } catch (...) {
43979       {
43980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43981       };
43982     }
43983   }
43984
43985   jresult = (void *)result;
43986   return jresult;
43987 }
43988
43989
43990 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_1(float jarg1, float jarg2) {
43991   void * jresult ;
43992   float arg1 ;
43993   float arg2 ;
43994   Dali::TimePeriod *result = 0 ;
43995
43996   arg1 = (float)jarg1;
43997   arg2 = (float)jarg2;
43998   {
43999     try {
44000       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1,arg2);
44001     } catch (std::out_of_range& e) {
44002       {
44003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44004       };
44005     } catch (std::exception& e) {
44006       {
44007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44008       };
44009     } catch (Dali::DaliException e) {
44010       {
44011         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44012       };
44013     } catch (...) {
44014       {
44015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44016       };
44017     }
44018   }
44019
44020   jresult = (void *)result;
44021   return jresult;
44022 }
44023
44024
44025 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimePeriod(void * jarg1) {
44026   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44027
44028   arg1 = (Dali::TimePeriod *)jarg1;
44029   {
44030     try {
44031       delete arg1;
44032     } catch (std::out_of_range& e) {
44033       {
44034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44035       };
44036     } catch (std::exception& e) {
44037       {
44038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44039       };
44040     } catch (Dali::DaliException e) {
44041       {
44042         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44043       };
44044     } catch (...) {
44045       {
44046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44047       };
44048     }
44049   }
44050
44051 }
44052
44053
44054 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_set(void * jarg1, float jarg2) {
44055   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44056   float arg2 ;
44057
44058   arg1 = (Dali::TimePeriod *)jarg1;
44059   arg2 = (float)jarg2;
44060   if (arg1) (arg1)->delaySeconds = arg2;
44061 }
44062
44063
44064 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_get(void * jarg1) {
44065   float jresult ;
44066   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44067   float result;
44068
44069   arg1 = (Dali::TimePeriod *)jarg1;
44070   result = (float) ((arg1)->delaySeconds);
44071   jresult = result;
44072   return jresult;
44073 }
44074
44075
44076 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_set(void * jarg1, float jarg2) {
44077   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44078   float arg2 ;
44079
44080   arg1 = (Dali::TimePeriod *)jarg1;
44081   arg2 = (float)jarg2;
44082   if (arg1) (arg1)->durationSeconds = arg2;
44083 }
44084
44085
44086 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_get(void * jarg1) {
44087   float jresult ;
44088   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44089   float result;
44090
44091   arg1 = (Dali::TimePeriod *)jarg1;
44092   result = (float) ((arg1)->durationSeconds);
44093   jresult = result;
44094   return jresult;
44095 }
44096
44097 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_VALUE_get() {
44098   int jresult ;
44099   int result;
44100
44101   result = (int)Dali::LinearConstrainer::Property::VALUE;
44102   jresult = (int)result;
44103   return jresult;
44104 }
44105
44106
44107 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_PROGRESS_get() {
44108   int jresult ;
44109   int result;
44110
44111   result = (int)Dali::LinearConstrainer::Property::PROGRESS;
44112   jresult = (int)result;
44113   return jresult;
44114 }
44115
44116
44117 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer_Property() {
44118   void * jresult ;
44119   Dali::LinearConstrainer::Property *result = 0 ;
44120
44121   {
44122     try {
44123       result = (Dali::LinearConstrainer::Property *)new Dali::LinearConstrainer::Property();
44124     } catch (std::out_of_range& e) {
44125       {
44126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44127       };
44128     } catch (std::exception& e) {
44129       {
44130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44131       };
44132     } catch (Dali::DaliException e) {
44133       {
44134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44135       };
44136     } catch (...) {
44137       {
44138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44139       };
44140     }
44141   }
44142
44143   jresult = (void *)result;
44144   return jresult;
44145 }
44146
44147
44148 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer_Property(void * jarg1) {
44149   Dali::LinearConstrainer::Property *arg1 = (Dali::LinearConstrainer::Property *) 0 ;
44150
44151   arg1 = (Dali::LinearConstrainer::Property *)jarg1;
44152   {
44153     try {
44154       delete arg1;
44155     } catch (std::out_of_range& e) {
44156       {
44157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44158       };
44159     } catch (std::exception& e) {
44160       {
44161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44162       };
44163     } catch (Dali::DaliException e) {
44164       {
44165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44166       };
44167     } catch (...) {
44168       {
44169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44170       };
44171     }
44172   }
44173
44174 }
44175
44176
44177 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_New() {
44178   void * jresult ;
44179   Dali::LinearConstrainer result;
44180
44181   {
44182     try {
44183       result = Dali::LinearConstrainer::New();
44184     } catch (std::out_of_range& e) {
44185       {
44186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44187       };
44188     } catch (std::exception& e) {
44189       {
44190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44191       };
44192     } catch (Dali::DaliException e) {
44193       {
44194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44195       };
44196     } catch (...) {
44197       {
44198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44199       };
44200     }
44201   }
44202
44203   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
44204   return jresult;
44205 }
44206
44207
44208 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_DownCast(void * jarg1) {
44209   void * jresult ;
44210   Dali::BaseHandle arg1 ;
44211   Dali::BaseHandle *argp1 ;
44212   Dali::LinearConstrainer result;
44213
44214   argp1 = (Dali::BaseHandle *)jarg1;
44215   if (!argp1) {
44216     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
44217     return 0;
44218   }
44219   arg1 = *argp1;
44220   {
44221     try {
44222       result = Dali::LinearConstrainer::DownCast(arg1);
44223     } catch (std::out_of_range& e) {
44224       {
44225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44226       };
44227     } catch (std::exception& e) {
44228       {
44229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44230       };
44231     } catch (Dali::DaliException e) {
44232       {
44233         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44234       };
44235     } catch (...) {
44236       {
44237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44238       };
44239     }
44240   }
44241
44242   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
44243   return jresult;
44244 }
44245
44246
44247 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_0() {
44248   void * jresult ;
44249   Dali::LinearConstrainer *result = 0 ;
44250
44251   {
44252     try {
44253       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer();
44254     } catch (std::out_of_range& e) {
44255       {
44256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44257       };
44258     } catch (std::exception& e) {
44259       {
44260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44261       };
44262     } catch (Dali::DaliException e) {
44263       {
44264         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44265       };
44266     } catch (...) {
44267       {
44268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44269       };
44270     }
44271   }
44272
44273   jresult = (void *)result;
44274   return jresult;
44275 }
44276
44277
44278 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer(void * jarg1) {
44279   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44280
44281   arg1 = (Dali::LinearConstrainer *)jarg1;
44282   {
44283     try {
44284       delete arg1;
44285     } catch (std::out_of_range& e) {
44286       {
44287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44288       };
44289     } catch (std::exception& e) {
44290       {
44291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44292       };
44293     } catch (Dali::DaliException e) {
44294       {
44295         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44296       };
44297     } catch (...) {
44298       {
44299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44300       };
44301     }
44302   }
44303
44304 }
44305
44306
44307 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_1(void * jarg1) {
44308   void * jresult ;
44309   Dali::LinearConstrainer *arg1 = 0 ;
44310   Dali::LinearConstrainer *result = 0 ;
44311
44312   arg1 = (Dali::LinearConstrainer *)jarg1;
44313   if (!arg1) {
44314     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
44315     return 0;
44316   }
44317   {
44318     try {
44319       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer((Dali::LinearConstrainer const &)*arg1);
44320     } catch (std::out_of_range& e) {
44321       {
44322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44323       };
44324     } catch (std::exception& e) {
44325       {
44326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44327       };
44328     } catch (Dali::DaliException e) {
44329       {
44330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44331       };
44332     } catch (...) {
44333       {
44334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44335       };
44336     }
44337   }
44338
44339   jresult = (void *)result;
44340   return jresult;
44341 }
44342
44343
44344 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_Assign(void * jarg1, void * jarg2) {
44345   void * jresult ;
44346   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44347   Dali::LinearConstrainer *arg2 = 0 ;
44348   Dali::LinearConstrainer *result = 0 ;
44349
44350   arg1 = (Dali::LinearConstrainer *)jarg1;
44351   arg2 = (Dali::LinearConstrainer *)jarg2;
44352   if (!arg2) {
44353     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
44354     return 0;
44355   }
44356   {
44357     try {
44358       result = (Dali::LinearConstrainer *) &(arg1)->operator =((Dali::LinearConstrainer const &)*arg2);
44359     } catch (std::out_of_range& e) {
44360       {
44361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44362       };
44363     } catch (std::exception& e) {
44364       {
44365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44366       };
44367     } catch (Dali::DaliException e) {
44368       {
44369         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44370       };
44371     } catch (...) {
44372       {
44373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44374       };
44375     }
44376   }
44377
44378   jresult = (void *)result;
44379   return jresult;
44380 }
44381
44382
44383 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
44384   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44385   SwigValueWrapper< Dali::Property > arg2 ;
44386   SwigValueWrapper< Dali::Property > arg3 ;
44387   Dali::Vector2 *arg4 = 0 ;
44388   Dali::Vector2 *arg5 = 0 ;
44389   Dali::Property *argp2 ;
44390   Dali::Property *argp3 ;
44391
44392   arg1 = (Dali::LinearConstrainer *)jarg1;
44393   argp2 = (Dali::Property *)jarg2;
44394   if (!argp2) {
44395     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44396     return ;
44397   }
44398   arg2 = *argp2;
44399   argp3 = (Dali::Property *)jarg3;
44400   if (!argp3) {
44401     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44402     return ;
44403   }
44404   arg3 = *argp3;
44405   arg4 = (Dali::Vector2 *)jarg4;
44406   if (!arg4) {
44407     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44408     return ;
44409   }
44410   arg5 = (Dali::Vector2 *)jarg5;
44411   if (!arg5) {
44412     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44413     return ;
44414   }
44415   {
44416     try {
44417       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
44418     } catch (std::out_of_range& e) {
44419       {
44420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44421       };
44422     } catch (std::exception& e) {
44423       {
44424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44425       };
44426     } catch (Dali::DaliException e) {
44427       {
44428         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44429       };
44430     } catch (...) {
44431       {
44432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44433       };
44434     }
44435   }
44436
44437 }
44438
44439
44440 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
44441   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44442   SwigValueWrapper< Dali::Property > arg2 ;
44443   SwigValueWrapper< Dali::Property > arg3 ;
44444   Dali::Vector2 *arg4 = 0 ;
44445   Dali::Property *argp2 ;
44446   Dali::Property *argp3 ;
44447
44448   arg1 = (Dali::LinearConstrainer *)jarg1;
44449   argp2 = (Dali::Property *)jarg2;
44450   if (!argp2) {
44451     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44452     return ;
44453   }
44454   arg2 = *argp2;
44455   argp3 = (Dali::Property *)jarg3;
44456   if (!argp3) {
44457     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44458     return ;
44459   }
44460   arg3 = *argp3;
44461   arg4 = (Dali::Vector2 *)jarg4;
44462   if (!arg4) {
44463     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44464     return ;
44465   }
44466   {
44467     try {
44468       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
44469     } catch (std::out_of_range& e) {
44470       {
44471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44472       };
44473     } catch (std::exception& e) {
44474       {
44475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44476       };
44477     } catch (Dali::DaliException e) {
44478       {
44479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44480       };
44481     } catch (...) {
44482       {
44483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44484       };
44485     }
44486   }
44487
44488 }
44489
44490
44491 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Remove(void * jarg1, void * jarg2) {
44492   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44493   Dali::Handle *arg2 = 0 ;
44494
44495   arg1 = (Dali::LinearConstrainer *)jarg1;
44496   arg2 = (Dali::Handle *)jarg2;
44497   if (!arg2) {
44498     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
44499     return ;
44500   }
44501   {
44502     try {
44503       (arg1)->Remove(*arg2);
44504     } catch (std::out_of_range& e) {
44505       {
44506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44507       };
44508     } catch (std::exception& e) {
44509       {
44510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44511       };
44512     } catch (Dali::DaliException e) {
44513       {
44514         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44515       };
44516     } catch (...) {
44517       {
44518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44519       };
44520     }
44521   }
44522
44523 }
44524
44525
44526 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_FORWARD_get() {
44527   int jresult ;
44528   int result;
44529
44530   result = (int)Dali::PathConstrainer::Property::FORWARD;
44531   jresult = (int)result;
44532   return jresult;
44533 }
44534
44535
44536 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_POINTS_get() {
44537   int jresult ;
44538   int result;
44539
44540   result = (int)Dali::PathConstrainer::Property::POINTS;
44541   jresult = (int)result;
44542   return jresult;
44543 }
44544
44545
44546 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_CONTROL_POINTS_get() {
44547   int jresult ;
44548   int result;
44549
44550   result = (int)Dali::PathConstrainer::Property::CONTROL_POINTS;
44551   jresult = (int)result;
44552   return jresult;
44553 }
44554
44555
44556 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer_Property() {
44557   void * jresult ;
44558   Dali::PathConstrainer::Property *result = 0 ;
44559
44560   {
44561     try {
44562       result = (Dali::PathConstrainer::Property *)new Dali::PathConstrainer::Property();
44563     } catch (std::out_of_range& e) {
44564       {
44565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44566       };
44567     } catch (std::exception& e) {
44568       {
44569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44570       };
44571     } catch (Dali::DaliException e) {
44572       {
44573         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44574       };
44575     } catch (...) {
44576       {
44577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44578       };
44579     }
44580   }
44581
44582   jresult = (void *)result;
44583   return jresult;
44584 }
44585
44586
44587 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer_Property(void * jarg1) {
44588   Dali::PathConstrainer::Property *arg1 = (Dali::PathConstrainer::Property *) 0 ;
44589
44590   arg1 = (Dali::PathConstrainer::Property *)jarg1;
44591   {
44592     try {
44593       delete arg1;
44594     } catch (std::out_of_range& e) {
44595       {
44596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44597       };
44598     } catch (std::exception& e) {
44599       {
44600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44601       };
44602     } catch (Dali::DaliException e) {
44603       {
44604         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44605       };
44606     } catch (...) {
44607       {
44608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44609       };
44610     }
44611   }
44612
44613 }
44614
44615
44616 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_New() {
44617   void * jresult ;
44618   Dali::PathConstrainer result;
44619
44620   {
44621     try {
44622       result = Dali::PathConstrainer::New();
44623     } catch (std::out_of_range& e) {
44624       {
44625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44626       };
44627     } catch (std::exception& e) {
44628       {
44629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44630       };
44631     } catch (Dali::DaliException e) {
44632       {
44633         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44634       };
44635     } catch (...) {
44636       {
44637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44638       };
44639     }
44640   }
44641
44642   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
44643   return jresult;
44644 }
44645
44646
44647 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_DownCast(void * jarg1) {
44648   void * jresult ;
44649   Dali::BaseHandle arg1 ;
44650   Dali::BaseHandle *argp1 ;
44651   Dali::PathConstrainer result;
44652
44653   argp1 = (Dali::BaseHandle *)jarg1;
44654   if (!argp1) {
44655     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
44656     return 0;
44657   }
44658   arg1 = *argp1;
44659   {
44660     try {
44661       result = Dali::PathConstrainer::DownCast(arg1);
44662     } catch (std::out_of_range& e) {
44663       {
44664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44665       };
44666     } catch (std::exception& e) {
44667       {
44668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44669       };
44670     } catch (Dali::DaliException e) {
44671       {
44672         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44673       };
44674     } catch (...) {
44675       {
44676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44677       };
44678     }
44679   }
44680
44681   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
44682   return jresult;
44683 }
44684
44685
44686 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_0() {
44687   void * jresult ;
44688   Dali::PathConstrainer *result = 0 ;
44689
44690   {
44691     try {
44692       result = (Dali::PathConstrainer *)new Dali::PathConstrainer();
44693     } catch (std::out_of_range& e) {
44694       {
44695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44696       };
44697     } catch (std::exception& e) {
44698       {
44699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44700       };
44701     } catch (Dali::DaliException e) {
44702       {
44703         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44704       };
44705     } catch (...) {
44706       {
44707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44708       };
44709     }
44710   }
44711
44712   jresult = (void *)result;
44713   return jresult;
44714 }
44715
44716
44717 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer(void * jarg1) {
44718   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44719
44720   arg1 = (Dali::PathConstrainer *)jarg1;
44721   {
44722     try {
44723       delete arg1;
44724     } catch (std::out_of_range& e) {
44725       {
44726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44727       };
44728     } catch (std::exception& e) {
44729       {
44730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44731       };
44732     } catch (Dali::DaliException e) {
44733       {
44734         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44735       };
44736     } catch (...) {
44737       {
44738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44739       };
44740     }
44741   }
44742
44743 }
44744
44745
44746 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_1(void * jarg1) {
44747   void * jresult ;
44748   Dali::PathConstrainer *arg1 = 0 ;
44749   Dali::PathConstrainer *result = 0 ;
44750
44751   arg1 = (Dali::PathConstrainer *)jarg1;
44752   if (!arg1) {
44753     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
44754     return 0;
44755   }
44756   {
44757     try {
44758       result = (Dali::PathConstrainer *)new Dali::PathConstrainer((Dali::PathConstrainer const &)*arg1);
44759     } catch (std::out_of_range& e) {
44760       {
44761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44762       };
44763     } catch (std::exception& e) {
44764       {
44765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44766       };
44767     } catch (Dali::DaliException e) {
44768       {
44769         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44770       };
44771     } catch (...) {
44772       {
44773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44774       };
44775     }
44776   }
44777
44778   jresult = (void *)result;
44779   return jresult;
44780 }
44781
44782
44783 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_Assign(void * jarg1, void * jarg2) {
44784   void * jresult ;
44785   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44786   Dali::PathConstrainer *arg2 = 0 ;
44787   Dali::PathConstrainer *result = 0 ;
44788
44789   arg1 = (Dali::PathConstrainer *)jarg1;
44790   arg2 = (Dali::PathConstrainer *)jarg2;
44791   if (!arg2) {
44792     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
44793     return 0;
44794   }
44795   {
44796     try {
44797       result = (Dali::PathConstrainer *) &(arg1)->operator =((Dali::PathConstrainer const &)*arg2);
44798     } catch (std::out_of_range& e) {
44799       {
44800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44801       };
44802     } catch (std::exception& e) {
44803       {
44804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44805       };
44806     } catch (Dali::DaliException e) {
44807       {
44808         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44809       };
44810     } catch (...) {
44811       {
44812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44813       };
44814     }
44815   }
44816
44817   jresult = (void *)result;
44818   return jresult;
44819 }
44820
44821
44822 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
44823   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44824   SwigValueWrapper< Dali::Property > arg2 ;
44825   SwigValueWrapper< Dali::Property > arg3 ;
44826   Dali::Vector2 *arg4 = 0 ;
44827   Dali::Vector2 *arg5 = 0 ;
44828   Dali::Property *argp2 ;
44829   Dali::Property *argp3 ;
44830
44831   arg1 = (Dali::PathConstrainer *)jarg1;
44832   argp2 = (Dali::Property *)jarg2;
44833   if (!argp2) {
44834     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44835     return ;
44836   }
44837   arg2 = *argp2;
44838   argp3 = (Dali::Property *)jarg3;
44839   if (!argp3) {
44840     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44841     return ;
44842   }
44843   arg3 = *argp3;
44844   arg4 = (Dali::Vector2 *)jarg4;
44845   if (!arg4) {
44846     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44847     return ;
44848   }
44849   arg5 = (Dali::Vector2 *)jarg5;
44850   if (!arg5) {
44851     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44852     return ;
44853   }
44854   {
44855     try {
44856       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
44857     } catch (std::out_of_range& e) {
44858       {
44859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44860       };
44861     } catch (std::exception& e) {
44862       {
44863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44864       };
44865     } catch (Dali::DaliException e) {
44866       {
44867         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44868       };
44869     } catch (...) {
44870       {
44871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44872       };
44873     }
44874   }
44875
44876 }
44877
44878
44879 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
44880   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44881   SwigValueWrapper< Dali::Property > arg2 ;
44882   SwigValueWrapper< Dali::Property > arg3 ;
44883   Dali::Vector2 *arg4 = 0 ;
44884   Dali::Property *argp2 ;
44885   Dali::Property *argp3 ;
44886
44887   arg1 = (Dali::PathConstrainer *)jarg1;
44888   argp2 = (Dali::Property *)jarg2;
44889   if (!argp2) {
44890     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44891     return ;
44892   }
44893   arg2 = *argp2;
44894   argp3 = (Dali::Property *)jarg3;
44895   if (!argp3) {
44896     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44897     return ;
44898   }
44899   arg3 = *argp3;
44900   arg4 = (Dali::Vector2 *)jarg4;
44901   if (!arg4) {
44902     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44903     return ;
44904   }
44905   {
44906     try {
44907       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
44908     } catch (std::out_of_range& e) {
44909       {
44910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44911       };
44912     } catch (std::exception& e) {
44913       {
44914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44915       };
44916     } catch (Dali::DaliException e) {
44917       {
44918         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44919       };
44920     } catch (...) {
44921       {
44922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44923       };
44924     }
44925   }
44926
44927 }
44928
44929
44930 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Remove(void * jarg1, void * jarg2) {
44931   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44932   Dali::Handle *arg2 = 0 ;
44933
44934   arg1 = (Dali::PathConstrainer *)jarg1;
44935   arg2 = (Dali::Handle *)jarg2;
44936   if (!arg2) {
44937     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
44938     return ;
44939   }
44940   {
44941     try {
44942       (arg1)->Remove(*arg2);
44943     } catch (std::out_of_range& e) {
44944       {
44945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44946       };
44947     } catch (std::exception& e) {
44948       {
44949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44950       };
44951     } catch (Dali::DaliException e) {
44952       {
44953         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44954       };
44955     } catch (...) {
44956       {
44957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44958       };
44959     }
44960   }
44961
44962 }
44963
44964
44965 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FittingModeDefault_get() {
44966   int jresult ;
44967   Dali::FittingMode::Type result;
44968
44969   result = (Dali::FittingMode::Type)(Dali::FittingMode::Type)Dali::FittingMode::DEFAULT;
44970   jresult = (int)result;
44971   return jresult;
44972 }
44973
44974
44975 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_DEFAULT_get() {
44976   int jresult ;
44977   Dali::SamplingMode::Type result;
44978
44979   result = (Dali::SamplingMode::Type)(Dali::SamplingMode::Type)Dali::SamplingMode::DEFAULT;
44980   jresult = (int)result;
44981   return jresult;
44982 }
44983
44984
44985 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BufferImage__SWIG_0() {
44986   void * jresult ;
44987   Dali::BufferImage *result = 0 ;
44988
44989   {
44990     try {
44991       result = (Dali::BufferImage *)new Dali::BufferImage();
44992     } catch (std::out_of_range& e) {
44993       {
44994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44995       };
44996     } catch (std::exception& e) {
44997       {
44998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44999       };
45000     } catch (Dali::DaliException e) {
45001       {
45002         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45003       };
45004     } catch (...) {
45005       {
45006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45007       };
45008     }
45009   }
45010
45011   jresult = (void *)result;
45012   return jresult;
45013 }
45014
45015
45016 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_0(unsigned int jarg1, unsigned int jarg2, int jarg3) {
45017   void * jresult ;
45018   unsigned int arg1 ;
45019   unsigned int arg2 ;
45020   Dali::Pixel::Format arg3 ;
45021   Dali::BufferImage result;
45022
45023   arg1 = (unsigned int)jarg1;
45024   arg2 = (unsigned int)jarg2;
45025   arg3 = (Dali::Pixel::Format)jarg3;
45026   {
45027     try {
45028       result = Dali::BufferImage::New(arg1,arg2,arg3);
45029     } catch (std::out_of_range& e) {
45030       {
45031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45032       };
45033     } catch (std::exception& e) {
45034       {
45035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45036       };
45037     } catch (Dali::DaliException e) {
45038       {
45039         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45040       };
45041     } catch (...) {
45042       {
45043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45044       };
45045     }
45046   }
45047
45048   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45049   return jresult;
45050 }
45051
45052
45053 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
45054   void * jresult ;
45055   unsigned int arg1 ;
45056   unsigned int arg2 ;
45057   Dali::BufferImage result;
45058
45059   arg1 = (unsigned int)jarg1;
45060   arg2 = (unsigned int)jarg2;
45061   {
45062     try {
45063       result = Dali::BufferImage::New(arg1,arg2);
45064     } catch (std::out_of_range& e) {
45065       {
45066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45067       };
45068     } catch (std::exception& e) {
45069       {
45070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45071       };
45072     } catch (Dali::DaliException e) {
45073       {
45074         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45075       };
45076     } catch (...) {
45077       {
45078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45079       };
45080     }
45081   }
45082
45083   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45084   return jresult;
45085 }
45086
45087
45088 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_2(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4, unsigned int jarg5) {
45089   void * jresult ;
45090   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
45091   unsigned int arg2 ;
45092   unsigned int arg3 ;
45093   Dali::Pixel::Format arg4 ;
45094   unsigned int arg5 ;
45095   Dali::BufferImage result;
45096
45097   arg1 = jarg1;
45098   arg2 = (unsigned int)jarg2;
45099   arg3 = (unsigned int)jarg3;
45100   arg4 = (Dali::Pixel::Format)jarg4;
45101   arg5 = (unsigned int)jarg5;
45102   {
45103     try {
45104       result = Dali::BufferImage::New(arg1,arg2,arg3,arg4,arg5);
45105     } catch (std::out_of_range& e) {
45106       {
45107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45108       };
45109     } catch (std::exception& e) {
45110       {
45111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45112       };
45113     } catch (Dali::DaliException e) {
45114       {
45115         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45116       };
45117     } catch (...) {
45118       {
45119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45120       };
45121     }
45122   }
45123
45124   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45125
45126
45127   return jresult;
45128 }
45129
45130
45131 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_3(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4) {
45132   void * jresult ;
45133   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
45134   unsigned int arg2 ;
45135   unsigned int arg3 ;
45136   Dali::Pixel::Format arg4 ;
45137   Dali::BufferImage result;
45138
45139   arg1 = jarg1;
45140   arg2 = (unsigned int)jarg2;
45141   arg3 = (unsigned int)jarg3;
45142   arg4 = (Dali::Pixel::Format)jarg4;
45143   {
45144     try {
45145       result = Dali::BufferImage::New(arg1,arg2,arg3,arg4);
45146     } catch (std::out_of_range& e) {
45147       {
45148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45149       };
45150     } catch (std::exception& e) {
45151       {
45152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45153       };
45154     } catch (Dali::DaliException e) {
45155       {
45156         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45157       };
45158     } catch (...) {
45159       {
45160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45161       };
45162     }
45163   }
45164
45165   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45166
45167
45168   return jresult;
45169 }
45170
45171
45172 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_4(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3) {
45173   void * jresult ;
45174   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
45175   unsigned int arg2 ;
45176   unsigned int arg3 ;
45177   Dali::BufferImage result;
45178
45179   arg1 = jarg1;
45180   arg2 = (unsigned int)jarg2;
45181   arg3 = (unsigned int)jarg3;
45182   {
45183     try {
45184       result = Dali::BufferImage::New(arg1,arg2,arg3);
45185     } catch (std::out_of_range& e) {
45186       {
45187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45188       };
45189     } catch (std::exception& e) {
45190       {
45191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45192       };
45193     } catch (Dali::DaliException e) {
45194       {
45195         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45196       };
45197     } catch (...) {
45198       {
45199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45200       };
45201     }
45202   }
45203
45204   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45205
45206
45207   return jresult;
45208 }
45209
45210
45211 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_DownCast(void * jarg1) {
45212   void * jresult ;
45213   Dali::BaseHandle arg1 ;
45214   Dali::BaseHandle *argp1 ;
45215   Dali::BufferImage result;
45216
45217   argp1 = (Dali::BaseHandle *)jarg1;
45218   if (!argp1) {
45219     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
45220     return 0;
45221   }
45222   arg1 = *argp1;
45223   {
45224     try {
45225       result = Dali::BufferImage::DownCast(arg1);
45226     } catch (std::out_of_range& e) {
45227       {
45228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45229       };
45230     } catch (std::exception& e) {
45231       {
45232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45233       };
45234     } catch (Dali::DaliException e) {
45235       {
45236         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45237       };
45238     } catch (...) {
45239       {
45240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45241       };
45242     }
45243   }
45244
45245   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45246   return jresult;
45247 }
45248
45249
45250 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BufferImage(void * jarg1) {
45251   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45252
45253   arg1 = (Dali::BufferImage *)jarg1;
45254   {
45255     try {
45256       delete arg1;
45257     } catch (std::out_of_range& e) {
45258       {
45259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45260       };
45261     } catch (std::exception& e) {
45262       {
45263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45264       };
45265     } catch (Dali::DaliException e) {
45266       {
45267         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45268       };
45269     } catch (...) {
45270       {
45271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45272       };
45273     }
45274   }
45275
45276 }
45277
45278
45279 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BufferImage__SWIG_1(void * jarg1) {
45280   void * jresult ;
45281   Dali::BufferImage *arg1 = 0 ;
45282   Dali::BufferImage *result = 0 ;
45283
45284   arg1 = (Dali::BufferImage *)jarg1;
45285   if (!arg1) {
45286     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BufferImage const & type is null", 0);
45287     return 0;
45288   }
45289   {
45290     try {
45291       result = (Dali::BufferImage *)new Dali::BufferImage((Dali::BufferImage const &)*arg1);
45292     } catch (std::out_of_range& e) {
45293       {
45294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45295       };
45296     } catch (std::exception& e) {
45297       {
45298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45299       };
45300     } catch (Dali::DaliException e) {
45301       {
45302         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45303       };
45304     } catch (...) {
45305       {
45306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45307       };
45308     }
45309   }
45310
45311   jresult = (void *)result;
45312   return jresult;
45313 }
45314
45315
45316 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_Assign(void * jarg1, void * jarg2) {
45317   void * jresult ;
45318   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45319   Dali::BufferImage *arg2 = 0 ;
45320   Dali::BufferImage *result = 0 ;
45321
45322   arg1 = (Dali::BufferImage *)jarg1;
45323   arg2 = (Dali::BufferImage *)jarg2;
45324   if (!arg2) {
45325     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BufferImage const & type is null", 0);
45326     return 0;
45327   }
45328   {
45329     try {
45330       result = (Dali::BufferImage *) &(arg1)->operator =((Dali::BufferImage const &)*arg2);
45331     } catch (std::out_of_range& e) {
45332       {
45333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45334       };
45335     } catch (std::exception& e) {
45336       {
45337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45338       };
45339     } catch (Dali::DaliException e) {
45340       {
45341         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45342       };
45343     } catch (...) {
45344       {
45345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45346       };
45347     }
45348   }
45349
45350   jresult = (void *)result;
45351   return jresult;
45352 }
45353
45354
45355 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_WHITE() {
45356   void * jresult ;
45357   Dali::BufferImage result;
45358
45359   {
45360     try {
45361       result = Dali::BufferImage::WHITE();
45362     } catch (std::out_of_range& e) {
45363       {
45364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45365       };
45366     } catch (std::exception& e) {
45367       {
45368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45369       };
45370     } catch (Dali::DaliException e) {
45371       {
45372         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45373       };
45374     } catch (...) {
45375       {
45376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45377       };
45378     }
45379   }
45380
45381   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45382   return jresult;
45383 }
45384
45385
45386 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_GetBuffer(void * jarg1) {
45387   void * jresult ;
45388   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45389   Dali::PixelBuffer *result = 0 ;
45390
45391   arg1 = (Dali::BufferImage *)jarg1;
45392   {
45393     try {
45394       result = (Dali::PixelBuffer *)(arg1)->GetBuffer();
45395     } catch (std::out_of_range& e) {
45396       {
45397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45398       };
45399     } catch (std::exception& e) {
45400       {
45401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45402       };
45403     } catch (Dali::DaliException e) {
45404       {
45405         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45406       };
45407     } catch (...) {
45408       {
45409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45410       };
45411     }
45412   }
45413
45414   jresult = (void *)result;
45415   return jresult;
45416 }
45417
45418
45419 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_GetBufferSize(void * jarg1) {
45420   unsigned int jresult ;
45421   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45422   unsigned int result;
45423
45424   arg1 = (Dali::BufferImage *)jarg1;
45425   {
45426     try {
45427       result = (unsigned int)((Dali::BufferImage const *)arg1)->GetBufferSize();
45428     } catch (std::out_of_range& e) {
45429       {
45430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45431       };
45432     } catch (std::exception& e) {
45433       {
45434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45435       };
45436     } catch (Dali::DaliException e) {
45437       {
45438         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45439       };
45440     } catch (...) {
45441       {
45442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45443       };
45444     }
45445   }
45446
45447   jresult = result;
45448   return jresult;
45449 }
45450
45451
45452 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_GetBufferStride(void * jarg1) {
45453   unsigned int jresult ;
45454   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45455   unsigned int result;
45456
45457   arg1 = (Dali::BufferImage *)jarg1;
45458   {
45459     try {
45460       result = (unsigned int)((Dali::BufferImage const *)arg1)->GetBufferStride();
45461     } catch (std::out_of_range& e) {
45462       {
45463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45464       };
45465     } catch (std::exception& e) {
45466       {
45467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45468       };
45469     } catch (Dali::DaliException e) {
45470       {
45471         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45472       };
45473     } catch (...) {
45474       {
45475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45476       };
45477     }
45478   }
45479
45480   jresult = result;
45481   return jresult;
45482 }
45483
45484
45485 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BufferImage_GetPixelFormat(void * jarg1) {
45486   int jresult ;
45487   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45488   Dali::Pixel::Format result;
45489
45490   arg1 = (Dali::BufferImage *)jarg1;
45491   {
45492     try {
45493       result = (Dali::Pixel::Format)((Dali::BufferImage const *)arg1)->GetPixelFormat();
45494     } catch (std::out_of_range& e) {
45495       {
45496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45497       };
45498     } catch (std::exception& e) {
45499       {
45500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45501       };
45502     } catch (Dali::DaliException e) {
45503       {
45504         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45505       };
45506     } catch (...) {
45507       {
45508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45509       };
45510     }
45511   }
45512
45513   jresult = (int)result;
45514   return jresult;
45515 }
45516
45517
45518 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BufferImage_Update__SWIG_0(void * jarg1) {
45519   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45520
45521   arg1 = (Dali::BufferImage *)jarg1;
45522   {
45523     try {
45524       (arg1)->Update();
45525     } catch (std::out_of_range& e) {
45526       {
45527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45528       };
45529     } catch (std::exception& e) {
45530       {
45531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45532       };
45533     } catch (Dali::DaliException e) {
45534       {
45535         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45536       };
45537     } catch (...) {
45538       {
45539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45540       };
45541     }
45542   }
45543
45544 }
45545
45546
45547 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BufferImage_Update__SWIG_1(void * jarg1, void * jarg2) {
45548   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45549   SwigValueWrapper< Dali::Rect< unsigned int > > arg2 ;
45550   Dali::RectArea *argp2 ;
45551
45552   arg1 = (Dali::BufferImage *)jarg1;
45553   argp2 = (Dali::RectArea *)jarg2;
45554   if (!argp2) {
45555     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RectArea", 0);
45556     return ;
45557   }
45558   arg2 = *argp2;
45559   {
45560     try {
45561       (arg1)->Update(arg2);
45562     } catch (std::out_of_range& e) {
45563       {
45564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45565       };
45566     } catch (std::exception& e) {
45567       {
45568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45569       };
45570     } catch (Dali::DaliException e) {
45571       {
45572         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45573       };
45574     } catch (...) {
45575       {
45576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45577       };
45578     }
45579   }
45580
45581 }
45582
45583
45584 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_IsDataExternal(void * jarg1) {
45585   unsigned int jresult ;
45586   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45587   bool result;
45588
45589   arg1 = (Dali::BufferImage *)jarg1;
45590   {
45591     try {
45592       result = (bool)((Dali::BufferImage const *)arg1)->IsDataExternal();
45593     } catch (std::out_of_range& e) {
45594       {
45595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45596       };
45597     } catch (std::exception& e) {
45598       {
45599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45600       };
45601     } catch (Dali::DaliException e) {
45602       {
45603         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45604       };
45605     } catch (...) {
45606       {
45607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45608       };
45609     }
45610   }
45611
45612   jresult = result;
45613   return jresult;
45614 }
45615
45616
45617 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_EncodedBufferImage__SWIG_0() {
45618   void * jresult ;
45619   Dali::EncodedBufferImage *result = 0 ;
45620
45621   {
45622     try {
45623       result = (Dali::EncodedBufferImage *)new Dali::EncodedBufferImage();
45624     } catch (std::out_of_range& e) {
45625       {
45626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45627       };
45628     } catch (std::exception& e) {
45629       {
45630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45631       };
45632     } catch (Dali::DaliException e) {
45633       {
45634         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45635       };
45636     } catch (...) {
45637       {
45638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45639       };
45640     }
45641   }
45642
45643   jresult = (void *)result;
45644   return jresult;
45645 }
45646
45647
45648 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_0(void * jarg1, unsigned long jarg2) {
45649   void * jresult ;
45650   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
45651   std::size_t arg2 ;
45652   Dali::EncodedBufferImage result;
45653
45654   arg1 = (uint8_t *)jarg1;
45655   arg2 = (std::size_t)jarg2;
45656   {
45657     try {
45658       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2);
45659     } catch (std::out_of_range& e) {
45660       {
45661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45662       };
45663     } catch (std::exception& e) {
45664       {
45665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45666       };
45667     } catch (Dali::DaliException e) {
45668       {
45669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45670       };
45671     } catch (...) {
45672       {
45673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45674       };
45675     }
45676   }
45677
45678   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
45679   return jresult;
45680 }
45681
45682
45683 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
45684   void * jresult ;
45685   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
45686   std::size_t arg2 ;
45687   Dali::ImageDimensions arg3 ;
45688   Dali::FittingMode::Type arg4 ;
45689   Dali::SamplingMode::Type arg5 ;
45690   bool arg6 ;
45691   Dali::ImageDimensions *argp3 ;
45692   Dali::EncodedBufferImage result;
45693
45694   arg1 = (uint8_t *)jarg1;
45695   arg2 = (std::size_t)jarg2;
45696   argp3 = (Dali::ImageDimensions *)jarg3;
45697   if (!argp3) {
45698     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
45699     return 0;
45700   }
45701   arg3 = *argp3;
45702   arg4 = (Dali::FittingMode::Type)jarg4;
45703   arg5 = (Dali::SamplingMode::Type)jarg5;
45704   arg6 = jarg6 ? true : false;
45705   {
45706     try {
45707       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2,arg3,arg4,arg5,arg6);
45708     } catch (std::out_of_range& e) {
45709       {
45710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45711       };
45712     } catch (std::exception& e) {
45713       {
45714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45715       };
45716     } catch (Dali::DaliException e) {
45717       {
45718         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45719       };
45720     } catch (...) {
45721       {
45722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45723       };
45724     }
45725   }
45726
45727   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
45728   return jresult;
45729 }
45730
45731
45732 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_2(void * jarg1, unsigned long jarg2, void * jarg3, int jarg4, int jarg5) {
45733   void * jresult ;
45734   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
45735   std::size_t arg2 ;
45736   Dali::ImageDimensions arg3 ;
45737   Dali::FittingMode::Type arg4 ;
45738   Dali::SamplingMode::Type arg5 ;
45739   Dali::ImageDimensions *argp3 ;
45740   Dali::EncodedBufferImage result;
45741
45742   arg1 = (uint8_t *)jarg1;
45743   arg2 = (std::size_t)jarg2;
45744   argp3 = (Dali::ImageDimensions *)jarg3;
45745   if (!argp3) {
45746     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
45747     return 0;
45748   }
45749   arg3 = *argp3;
45750   arg4 = (Dali::FittingMode::Type)jarg4;
45751   arg5 = (Dali::SamplingMode::Type)jarg5;
45752   {
45753     try {
45754       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2,arg3,arg4,arg5);
45755     } catch (std::out_of_range& e) {
45756       {
45757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45758       };
45759     } catch (std::exception& e) {
45760       {
45761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45762       };
45763     } catch (Dali::DaliException e) {
45764       {
45765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45766       };
45767     } catch (...) {
45768       {
45769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45770       };
45771     }
45772   }
45773
45774   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
45775   return jresult;
45776 }
45777
45778
45779 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_DownCast(void * jarg1) {
45780   void * jresult ;
45781   Dali::BaseHandle arg1 ;
45782   Dali::BaseHandle *argp1 ;
45783   Dali::EncodedBufferImage result;
45784
45785   argp1 = (Dali::BaseHandle *)jarg1;
45786   if (!argp1) {
45787     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
45788     return 0;
45789   }
45790   arg1 = *argp1;
45791   {
45792     try {
45793       result = Dali::EncodedBufferImage::DownCast(arg1);
45794     } catch (std::out_of_range& e) {
45795       {
45796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45797       };
45798     } catch (std::exception& e) {
45799       {
45800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45801       };
45802     } catch (Dali::DaliException e) {
45803       {
45804         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45805       };
45806     } catch (...) {
45807       {
45808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45809       };
45810     }
45811   }
45812
45813   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
45814   return jresult;
45815 }
45816
45817
45818 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_EncodedBufferImage(void * jarg1) {
45819   Dali::EncodedBufferImage *arg1 = (Dali::EncodedBufferImage *) 0 ;
45820
45821   arg1 = (Dali::EncodedBufferImage *)jarg1;
45822   {
45823     try {
45824       delete arg1;
45825     } catch (std::out_of_range& e) {
45826       {
45827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45828       };
45829     } catch (std::exception& e) {
45830       {
45831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45832       };
45833     } catch (Dali::DaliException e) {
45834       {
45835         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45836       };
45837     } catch (...) {
45838       {
45839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45840       };
45841     }
45842   }
45843
45844 }
45845
45846
45847 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_EncodedBufferImage__SWIG_1(void * jarg1) {
45848   void * jresult ;
45849   Dali::EncodedBufferImage *arg1 = 0 ;
45850   Dali::EncodedBufferImage *result = 0 ;
45851
45852   arg1 = (Dali::EncodedBufferImage *)jarg1;
45853   if (!arg1) {
45854     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::EncodedBufferImage const & type is null", 0);
45855     return 0;
45856   }
45857   {
45858     try {
45859       result = (Dali::EncodedBufferImage *)new Dali::EncodedBufferImage((Dali::EncodedBufferImage const &)*arg1);
45860     } catch (std::out_of_range& e) {
45861       {
45862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45863       };
45864     } catch (std::exception& e) {
45865       {
45866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45867       };
45868     } catch (Dali::DaliException e) {
45869       {
45870         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45871       };
45872     } catch (...) {
45873       {
45874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45875       };
45876     }
45877   }
45878
45879   jresult = (void *)result;
45880   return jresult;
45881 }
45882
45883
45884 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_Assign(void * jarg1, void * jarg2) {
45885   void * jresult ;
45886   Dali::EncodedBufferImage *arg1 = (Dali::EncodedBufferImage *) 0 ;
45887   Dali::EncodedBufferImage *arg2 = 0 ;
45888   Dali::EncodedBufferImage *result = 0 ;
45889
45890   arg1 = (Dali::EncodedBufferImage *)jarg1;
45891   arg2 = (Dali::EncodedBufferImage *)jarg2;
45892   if (!arg2) {
45893     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::EncodedBufferImage const & type is null", 0);
45894     return 0;
45895   }
45896   {
45897     try {
45898       result = (Dali::EncodedBufferImage *) &(arg1)->operator =((Dali::EncodedBufferImage const &)*arg2);
45899     } catch (std::out_of_range& e) {
45900       {
45901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45902       };
45903     } catch (std::exception& e) {
45904       {
45905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45906       };
45907     } catch (Dali::DaliException e) {
45908       {
45909         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45910       };
45911     } catch (...) {
45912       {
45913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45914       };
45915     }
45916   }
45917
45918   jresult = (void *)result;
45919   return jresult;
45920 }
45921
45922
45923 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NativeImage__SWIG_0() {
45924   void * jresult ;
45925   Dali::NativeImage *result = 0 ;
45926
45927   {
45928     try {
45929       result = (Dali::NativeImage *)new Dali::NativeImage();
45930     } catch (std::out_of_range& e) {
45931       {
45932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45933       };
45934     } catch (std::exception& e) {
45935       {
45936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45937       };
45938     } catch (Dali::DaliException e) {
45939       {
45940         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45941       };
45942     } catch (...) {
45943       {
45944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45945       };
45946     }
45947   }
45948
45949   jresult = (void *)result;
45950   return jresult;
45951 }
45952
45953
45954 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_NativeImage(void * jarg1) {
45955   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
45956
45957   arg1 = (Dali::NativeImage *)jarg1;
45958   {
45959     try {
45960       delete arg1;
45961     } catch (std::out_of_range& e) {
45962       {
45963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45964       };
45965     } catch (std::exception& e) {
45966       {
45967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45968       };
45969     } catch (Dali::DaliException e) {
45970       {
45971         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45972       };
45973     } catch (...) {
45974       {
45975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45976       };
45977     }
45978   }
45979
45980 }
45981
45982
45983 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NativeImage__SWIG_1(void * jarg1) {
45984   void * jresult ;
45985   Dali::NativeImage *arg1 = 0 ;
45986   Dali::NativeImage *result = 0 ;
45987
45988   arg1 = (Dali::NativeImage *)jarg1;
45989   if (!arg1) {
45990     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImage const & type is null", 0);
45991     return 0;
45992   }
45993   {
45994     try {
45995       result = (Dali::NativeImage *)new Dali::NativeImage((Dali::NativeImage const &)*arg1);
45996     } catch (std::out_of_range& e) {
45997       {
45998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45999       };
46000     } catch (std::exception& e) {
46001       {
46002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46003       };
46004     } catch (Dali::DaliException e) {
46005       {
46006         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46007       };
46008     } catch (...) {
46009       {
46010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46011       };
46012     }
46013   }
46014
46015   jresult = (void *)result;
46016   return jresult;
46017 }
46018
46019
46020 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_Assign(void * jarg1, void * jarg2) {
46021   void * jresult ;
46022   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
46023   Dali::NativeImage *arg2 = 0 ;
46024   Dali::NativeImage *result = 0 ;
46025
46026   arg1 = (Dali::NativeImage *)jarg1;
46027   arg2 = (Dali::NativeImage *)jarg2;
46028   if (!arg2) {
46029     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImage const & type is null", 0);
46030     return 0;
46031   }
46032   {
46033     try {
46034       result = (Dali::NativeImage *) &(arg1)->operator =((Dali::NativeImage const &)*arg2);
46035     } catch (std::out_of_range& e) {
46036       {
46037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46038       };
46039     } catch (std::exception& e) {
46040       {
46041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46042       };
46043     } catch (Dali::DaliException e) {
46044       {
46045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46046       };
46047     } catch (...) {
46048       {
46049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46050       };
46051     }
46052   }
46053
46054   jresult = (void *)result;
46055   return jresult;
46056 }
46057
46058
46059 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImage_CreateGlTexture(void * jarg1) {
46060   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
46061
46062   arg1 = (Dali::NativeImage *)jarg1;
46063   {
46064     try {
46065       (arg1)->CreateGlTexture();
46066     } catch (std::out_of_range& e) {
46067       {
46068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46069       };
46070     } catch (std::exception& e) {
46071       {
46072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46073       };
46074     } catch (Dali::DaliException e) {
46075       {
46076         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46077       };
46078     } catch (...) {
46079       {
46080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46081       };
46082     }
46083   }
46084
46085 }
46086
46087
46088 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_New(void * jarg1) {
46089   void * jresult ;
46090   NativeImageInterface *arg1 = 0 ;
46091   Dali::NativeImage result;
46092
46093   arg1 = (NativeImageInterface *)jarg1;
46094   if (!arg1) {
46095     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
46096     return 0;
46097   }
46098   {
46099     try {
46100       result = Dali::NativeImage::New(*arg1);
46101     } catch (std::out_of_range& e) {
46102       {
46103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46104       };
46105     } catch (std::exception& e) {
46106       {
46107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46108       };
46109     } catch (Dali::DaliException e) {
46110       {
46111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46112       };
46113     } catch (...) {
46114       {
46115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46116       };
46117     }
46118   }
46119
46120   jresult = new Dali::NativeImage((const Dali::NativeImage &)result);
46121   return jresult;
46122 }
46123
46124
46125 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_DownCast(void * jarg1) {
46126   void * jresult ;
46127   Dali::BaseHandle arg1 ;
46128   Dali::BaseHandle *argp1 ;
46129   Dali::NativeImage result;
46130
46131   argp1 = (Dali::BaseHandle *)jarg1;
46132   if (!argp1) {
46133     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
46134     return 0;
46135   }
46136   arg1 = *argp1;
46137   {
46138     try {
46139       result = Dali::NativeImage::DownCast(arg1);
46140     } catch (std::out_of_range& e) {
46141       {
46142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46143       };
46144     } catch (std::exception& e) {
46145       {
46146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46147       };
46148     } catch (Dali::DaliException e) {
46149       {
46150         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46151       };
46152     } catch (...) {
46153       {
46154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46155       };
46156     }
46157   }
46158
46159   jresult = new Dali::NativeImage((const Dali::NativeImage &)result);
46160   return jresult;
46161 }
46162
46163
46164 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_NativeImage_GetCustomFragmentPreFix(void * jarg1) {
46165   char * jresult ;
46166   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
46167   char *result = 0 ;
46168
46169   arg1 = (Dali::NativeImage *)jarg1;
46170   {
46171     try {
46172       result = (char *)(arg1)->GetCustomFragmentPreFix();
46173     } catch (std::out_of_range& e) {
46174       {
46175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46176       };
46177     } catch (std::exception& e) {
46178       {
46179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46180       };
46181     } catch (Dali::DaliException e) {
46182       {
46183         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46184       };
46185     } catch (...) {
46186       {
46187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46188       };
46189     }
46190   }
46191
46192   jresult = SWIG_csharp_string_callback((const char *)result);
46193   return jresult;
46194 }
46195
46196
46197 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_NativeImage_GetCustomSamplerTypename(void * jarg1) {
46198   char * jresult ;
46199   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
46200   char *result = 0 ;
46201
46202   arg1 = (Dali::NativeImage *)jarg1;
46203   {
46204     try {
46205       result = (char *)(arg1)->GetCustomSamplerTypename();
46206     } catch (std::out_of_range& e) {
46207       {
46208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46209       };
46210     } catch (std::exception& e) {
46211       {
46212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46213       };
46214     } catch (Dali::DaliException e) {
46215       {
46216         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46217       };
46218     } catch (...) {
46219       {
46220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46221       };
46222     }
46223   }
46224
46225   jresult = SWIG_csharp_string_callback((const char *)result);
46226   return jresult;
46227 }
46228
46229
46230 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GlExtensionCreate(void * jarg1) {
46231   unsigned int jresult ;
46232   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46233   bool result;
46234
46235   arg1 = (Dali::NativeImageInterface *)jarg1;
46236   {
46237     try {
46238       result = (bool)(arg1)->GlExtensionCreate();
46239     } catch (std::out_of_range& e) {
46240       {
46241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46242       };
46243     } catch (std::exception& e) {
46244       {
46245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46246       };
46247     } catch (Dali::DaliException e) {
46248       {
46249         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46250       };
46251     } catch (...) {
46252       {
46253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46254       };
46255     }
46256   }
46257
46258   jresult = result;
46259   return jresult;
46260 }
46261
46262
46263 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_GlExtensionDestroy(void * jarg1) {
46264   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46265
46266   arg1 = (Dali::NativeImageInterface *)jarg1;
46267   {
46268     try {
46269       (arg1)->GlExtensionDestroy();
46270     } catch (std::out_of_range& e) {
46271       {
46272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46273       };
46274     } catch (std::exception& e) {
46275       {
46276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46277       };
46278     } catch (Dali::DaliException e) {
46279       {
46280         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46281       };
46282     } catch (...) {
46283       {
46284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46285       };
46286     }
46287   }
46288
46289 }
46290
46291
46292 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_TargetTexture(void * jarg1) {
46293   unsigned int jresult ;
46294   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46295   unsigned int result;
46296
46297   arg1 = (Dali::NativeImageInterface *)jarg1;
46298   {
46299     try {
46300       result = (unsigned int)(arg1)->TargetTexture();
46301     } catch (std::out_of_range& e) {
46302       {
46303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46304       };
46305     } catch (std::exception& e) {
46306       {
46307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46308       };
46309     } catch (Dali::DaliException e) {
46310       {
46311         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46312       };
46313     } catch (...) {
46314       {
46315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46316       };
46317     }
46318   }
46319
46320   jresult = result;
46321   return jresult;
46322 }
46323
46324
46325 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_PrepareTexture(void * jarg1) {
46326   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46327
46328   arg1 = (Dali::NativeImageInterface *)jarg1;
46329   {
46330     try {
46331       (arg1)->PrepareTexture();
46332     } catch (std::out_of_range& e) {
46333       {
46334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46335       };
46336     } catch (std::exception& e) {
46337       {
46338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46339       };
46340     } catch (Dali::DaliException e) {
46341       {
46342         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46343       };
46344     } catch (...) {
46345       {
46346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46347       };
46348     }
46349   }
46350
46351 }
46352
46353
46354 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetWidth(void * jarg1) {
46355   unsigned int jresult ;
46356   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46357   unsigned int result;
46358
46359   arg1 = (Dali::NativeImageInterface *)jarg1;
46360   {
46361     try {
46362       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetWidth();
46363     } catch (std::out_of_range& e) {
46364       {
46365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46366       };
46367     } catch (std::exception& e) {
46368       {
46369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46370       };
46371     } catch (Dali::DaliException e) {
46372       {
46373         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46374       };
46375     } catch (...) {
46376       {
46377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46378       };
46379     }
46380   }
46381
46382   jresult = result;
46383   return jresult;
46384 }
46385
46386
46387 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetHeight(void * jarg1) {
46388   unsigned int jresult ;
46389   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46390   unsigned int result;
46391
46392   arg1 = (Dali::NativeImageInterface *)jarg1;
46393   {
46394     try {
46395       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetHeight();
46396     } catch (std::out_of_range& e) {
46397       {
46398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46399       };
46400     } catch (std::exception& e) {
46401       {
46402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46403       };
46404     } catch (Dali::DaliException e) {
46405       {
46406         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46407       };
46408     } catch (...) {
46409       {
46410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46411       };
46412     }
46413   }
46414
46415   jresult = result;
46416   return jresult;
46417 }
46418
46419
46420 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_RequiresBlending(void * jarg1) {
46421   unsigned int jresult ;
46422   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46423   bool result;
46424
46425   arg1 = (Dali::NativeImageInterface *)jarg1;
46426   {
46427     try {
46428       result = (bool)((Dali::NativeImageInterface const *)arg1)->RequiresBlending();
46429     } catch (std::out_of_range& e) {
46430       {
46431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46432       };
46433     } catch (std::exception& e) {
46434       {
46435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46436       };
46437     } catch (Dali::DaliException e) {
46438       {
46439         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46440       };
46441     } catch (...) {
46442       {
46443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46444       };
46445     }
46446   }
46447
46448   jresult = result;
46449   return jresult;
46450 }
46451
46452
46453 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_GetImageSize(char * jarg1) {
46454   void * jresult ;
46455   std::string *arg1 = 0 ;
46456   Dali::ImageDimensions result;
46457
46458   if (!jarg1) {
46459     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46460     return 0;
46461   }
46462   std::string arg1_str(jarg1);
46463   arg1 = &arg1_str;
46464   {
46465     try {
46466       result = Dali::ResourceImage::GetImageSize((std::string const &)*arg1);
46467     } catch (std::out_of_range& e) {
46468       {
46469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46470       };
46471     } catch (std::exception& e) {
46472       {
46473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46474       };
46475     } catch (Dali::DaliException e) {
46476       {
46477         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46478       };
46479     } catch (...) {
46480       {
46481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46482       };
46483     }
46484   }
46485
46486   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
46487
46488   //argout typemap for const std::string&
46489
46490   return jresult;
46491 }
46492
46493
46494 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImage__SWIG_0() {
46495   void * jresult ;
46496   Dali::ResourceImage *result = 0 ;
46497
46498   {
46499     try {
46500       result = (Dali::ResourceImage *)new Dali::ResourceImage();
46501     } catch (std::out_of_range& e) {
46502       {
46503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46504       };
46505     } catch (std::exception& e) {
46506       {
46507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46508       };
46509     } catch (Dali::DaliException e) {
46510       {
46511         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46512       };
46513     } catch (...) {
46514       {
46515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46516       };
46517     }
46518   }
46519
46520   jresult = (void *)result;
46521   return jresult;
46522 }
46523
46524
46525 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ResourceImage(void * jarg1) {
46526   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
46527
46528   arg1 = (Dali::ResourceImage *)jarg1;
46529   {
46530     try {
46531       delete arg1;
46532     } catch (std::out_of_range& e) {
46533       {
46534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46535       };
46536     } catch (std::exception& e) {
46537       {
46538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46539       };
46540     } catch (Dali::DaliException e) {
46541       {
46542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46543       };
46544     } catch (...) {
46545       {
46546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46547       };
46548     }
46549   }
46550
46551 }
46552
46553
46554 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImage__SWIG_1(void * jarg1) {
46555   void * jresult ;
46556   Dali::ResourceImage *arg1 = 0 ;
46557   Dali::ResourceImage *result = 0 ;
46558
46559   arg1 = (Dali::ResourceImage *)jarg1;
46560   if (!arg1) {
46561     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ResourceImage const & type is null", 0);
46562     return 0;
46563   }
46564   {
46565     try {
46566       result = (Dali::ResourceImage *)new Dali::ResourceImage((Dali::ResourceImage const &)*arg1);
46567     } catch (std::out_of_range& e) {
46568       {
46569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46570       };
46571     } catch (std::exception& e) {
46572       {
46573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46574       };
46575     } catch (Dali::DaliException e) {
46576       {
46577         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46578       };
46579     } catch (...) {
46580       {
46581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46582       };
46583     }
46584   }
46585
46586   jresult = (void *)result;
46587   return jresult;
46588 }
46589
46590
46591 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_Assign(void * jarg1, void * jarg2) {
46592   void * jresult ;
46593   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
46594   Dali::ResourceImage *arg2 = 0 ;
46595   Dali::ResourceImage *result = 0 ;
46596
46597   arg1 = (Dali::ResourceImage *)jarg1;
46598   arg2 = (Dali::ResourceImage *)jarg2;
46599   if (!arg2) {
46600     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ResourceImage const & type is null", 0);
46601     return 0;
46602   }
46603   {
46604     try {
46605       result = (Dali::ResourceImage *) &(arg1)->operator =((Dali::ResourceImage const &)*arg2);
46606     } catch (std::out_of_range& e) {
46607       {
46608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46609       };
46610     } catch (std::exception& e) {
46611       {
46612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46613       };
46614     } catch (Dali::DaliException e) {
46615       {
46616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46617       };
46618     } catch (...) {
46619       {
46620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46621       };
46622     }
46623   }
46624
46625   jresult = (void *)result;
46626   return jresult;
46627 }
46628
46629
46630 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_0(char * jarg1, unsigned int jarg2) {
46631   void * jresult ;
46632   std::string *arg1 = 0 ;
46633   bool arg2 ;
46634   Dali::ResourceImage result;
46635
46636   if (!jarg1) {
46637     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46638     return 0;
46639   }
46640   std::string arg1_str(jarg1);
46641   arg1 = &arg1_str;
46642   arg2 = jarg2 ? true : false;
46643   {
46644     try {
46645       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2);
46646     } catch (std::out_of_range& e) {
46647       {
46648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46649       };
46650     } catch (std::exception& e) {
46651       {
46652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46653       };
46654     } catch (Dali::DaliException e) {
46655       {
46656         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46657       };
46658     } catch (...) {
46659       {
46660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46661       };
46662     }
46663   }
46664
46665   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46666
46667   //argout typemap for const std::string&
46668
46669   return jresult;
46670 }
46671
46672
46673 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_1(char * jarg1) {
46674   void * jresult ;
46675   std::string *arg1 = 0 ;
46676   Dali::ResourceImage result;
46677
46678   if (!jarg1) {
46679     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46680     return 0;
46681   }
46682   std::string arg1_str(jarg1);
46683   arg1 = &arg1_str;
46684   {
46685     try {
46686       result = Dali::ResourceImage::New((std::string const &)*arg1);
46687     } catch (std::out_of_range& e) {
46688       {
46689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46690       };
46691     } catch (std::exception& e) {
46692       {
46693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46694       };
46695     } catch (Dali::DaliException e) {
46696       {
46697         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46698       };
46699     } catch (...) {
46700       {
46701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46702       };
46703     }
46704   }
46705
46706   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46707
46708   //argout typemap for const std::string&
46709
46710   return jresult;
46711 }
46712
46713
46714 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
46715   void * jresult ;
46716   std::string *arg1 = 0 ;
46717   Dali::ImageDimensions arg2 ;
46718   Dali::FittingMode::Type arg3 ;
46719   Dali::SamplingMode::Type arg4 ;
46720   bool arg5 ;
46721   Dali::ImageDimensions *argp2 ;
46722   Dali::ResourceImage result;
46723
46724   if (!jarg1) {
46725     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46726     return 0;
46727   }
46728   std::string arg1_str(jarg1);
46729   arg1 = &arg1_str;
46730   argp2 = (Dali::ImageDimensions *)jarg2;
46731   if (!argp2) {
46732     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
46733     return 0;
46734   }
46735   arg2 = *argp2;
46736   arg3 = (Dali::FittingMode::Type)jarg3;
46737   arg4 = (Dali::SamplingMode::Type)jarg4;
46738   arg5 = jarg5 ? true : false;
46739   {
46740     try {
46741       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3,arg4,arg5);
46742     } catch (std::out_of_range& e) {
46743       {
46744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46745       };
46746     } catch (std::exception& e) {
46747       {
46748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46749       };
46750     } catch (Dali::DaliException e) {
46751       {
46752         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46753       };
46754     } catch (...) {
46755       {
46756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46757       };
46758     }
46759   }
46760
46761   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46762
46763   //argout typemap for const std::string&
46764
46765   return jresult;
46766 }
46767
46768
46769 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_3(char * jarg1, void * jarg2, int jarg3, int jarg4) {
46770   void * jresult ;
46771   std::string *arg1 = 0 ;
46772   Dali::ImageDimensions arg2 ;
46773   Dali::FittingMode::Type arg3 ;
46774   Dali::SamplingMode::Type arg4 ;
46775   Dali::ImageDimensions *argp2 ;
46776   Dali::ResourceImage result;
46777
46778   if (!jarg1) {
46779     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46780     return 0;
46781   }
46782   std::string arg1_str(jarg1);
46783   arg1 = &arg1_str;
46784   argp2 = (Dali::ImageDimensions *)jarg2;
46785   if (!argp2) {
46786     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
46787     return 0;
46788   }
46789   arg2 = *argp2;
46790   arg3 = (Dali::FittingMode::Type)jarg3;
46791   arg4 = (Dali::SamplingMode::Type)jarg4;
46792   {
46793     try {
46794       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3,arg4);
46795     } catch (std::out_of_range& e) {
46796       {
46797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46798       };
46799     } catch (std::exception& e) {
46800       {
46801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46802       };
46803     } catch (Dali::DaliException e) {
46804       {
46805         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46806       };
46807     } catch (...) {
46808       {
46809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46810       };
46811     }
46812   }
46813
46814   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46815
46816   //argout typemap for const std::string&
46817
46818   return jresult;
46819 }
46820
46821
46822 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_4(char * jarg1, void * jarg2, int jarg3) {
46823   void * jresult ;
46824   std::string *arg1 = 0 ;
46825   Dali::ImageDimensions arg2 ;
46826   Dali::FittingMode::Type arg3 ;
46827   Dali::ImageDimensions *argp2 ;
46828   Dali::ResourceImage result;
46829
46830   if (!jarg1) {
46831     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46832     return 0;
46833   }
46834   std::string arg1_str(jarg1);
46835   arg1 = &arg1_str;
46836   argp2 = (Dali::ImageDimensions *)jarg2;
46837   if (!argp2) {
46838     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
46839     return 0;
46840   }
46841   arg2 = *argp2;
46842   arg3 = (Dali::FittingMode::Type)jarg3;
46843   {
46844     try {
46845       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3);
46846     } catch (std::out_of_range& e) {
46847       {
46848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46849       };
46850     } catch (std::exception& e) {
46851       {
46852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46853       };
46854     } catch (Dali::DaliException e) {
46855       {
46856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46857       };
46858     } catch (...) {
46859       {
46860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46861       };
46862     }
46863   }
46864
46865   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46866
46867   //argout typemap for const std::string&
46868
46869   return jresult;
46870 }
46871
46872
46873 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_5(char * jarg1, void * jarg2) {
46874   void * jresult ;
46875   std::string *arg1 = 0 ;
46876   Dali::ImageDimensions arg2 ;
46877   Dali::ImageDimensions *argp2 ;
46878   Dali::ResourceImage result;
46879
46880   if (!jarg1) {
46881     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46882     return 0;
46883   }
46884   std::string arg1_str(jarg1);
46885   arg1 = &arg1_str;
46886   argp2 = (Dali::ImageDimensions *)jarg2;
46887   if (!argp2) {
46888     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
46889     return 0;
46890   }
46891   arg2 = *argp2;
46892   {
46893     try {
46894       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2);
46895     } catch (std::out_of_range& e) {
46896       {
46897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46898       };
46899     } catch (std::exception& e) {
46900       {
46901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46902       };
46903     } catch (Dali::DaliException e) {
46904       {
46905         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46906       };
46907     } catch (...) {
46908       {
46909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46910       };
46911     }
46912   }
46913
46914   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46915
46916   //argout typemap for const std::string&
46917
46918   return jresult;
46919 }
46920
46921
46922 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_DownCast(void * jarg1) {
46923   void * jresult ;
46924   Dali::BaseHandle arg1 ;
46925   Dali::BaseHandle *argp1 ;
46926   Dali::ResourceImage result;
46927
46928   argp1 = (Dali::BaseHandle *)jarg1;
46929   if (!argp1) {
46930     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
46931     return 0;
46932   }
46933   arg1 = *argp1;
46934   {
46935     try {
46936       result = Dali::ResourceImage::DownCast(arg1);
46937     } catch (std::out_of_range& e) {
46938       {
46939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46940       };
46941     } catch (std::exception& e) {
46942       {
46943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46944       };
46945     } catch (Dali::DaliException e) {
46946       {
46947         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46948       };
46949     } catch (...) {
46950       {
46951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46952       };
46953     }
46954   }
46955
46956   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46957   return jresult;
46958 }
46959
46960
46961 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ResourceImage_GetLoadingState(void * jarg1) {
46962   int jresult ;
46963   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
46964   Dali::LoadingState result;
46965
46966   arg1 = (Dali::ResourceImage *)jarg1;
46967   {
46968     try {
46969       result = (Dali::LoadingState)((Dali::ResourceImage const *)arg1)->GetLoadingState();
46970     } catch (std::out_of_range& e) {
46971       {
46972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46973       };
46974     } catch (std::exception& e) {
46975       {
46976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46977       };
46978     } catch (Dali::DaliException e) {
46979       {
46980         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46981       };
46982     } catch (...) {
46983       {
46984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46985       };
46986     }
46987   }
46988
46989   jresult = (int)result;
46990   return jresult;
46991 }
46992
46993
46994 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ResourceImage_GetUrl(void * jarg1) {
46995   char * jresult ;
46996   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
46997   std::string result;
46998
46999   arg1 = (Dali::ResourceImage *)jarg1;
47000   {
47001     try {
47002       result = ((Dali::ResourceImage const *)arg1)->GetUrl();
47003     } catch (std::out_of_range& e) {
47004       {
47005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47006       };
47007     } catch (std::exception& e) {
47008       {
47009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47010       };
47011     } catch (Dali::DaliException e) {
47012       {
47013         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47014       };
47015     } catch (...) {
47016       {
47017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47018       };
47019     }
47020   }
47021
47022   jresult = SWIG_csharp_string_callback((&result)->c_str());
47023   return jresult;
47024 }
47025
47026
47027 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImage_Reload(void * jarg1) {
47028   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
47029
47030   arg1 = (Dali::ResourceImage *)jarg1;
47031   {
47032     try {
47033       (arg1)->Reload();
47034     } catch (std::out_of_range& e) {
47035       {
47036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47037       };
47038     } catch (std::exception& e) {
47039       {
47040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47041       };
47042     } catch (Dali::DaliException e) {
47043       {
47044         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47045       };
47046     } catch (...) {
47047       {
47048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47049       };
47050     }
47051   }
47052
47053 }
47054
47055
47056 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_LoadingFinishedSignal(void * jarg1) {
47057   void * jresult ;
47058   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
47059   Dali::ResourceImage::ResourceImageSignal *result = 0 ;
47060
47061   arg1 = (Dali::ResourceImage *)jarg1;
47062   {
47063     try {
47064       result = (Dali::ResourceImage::ResourceImageSignal *) &(arg1)->LoadingFinishedSignal();
47065     } catch (std::out_of_range& e) {
47066       {
47067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47068       };
47069     } catch (std::exception& e) {
47070       {
47071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47072       };
47073     } catch (Dali::DaliException e) {
47074       {
47075         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47076       };
47077     } catch (...) {
47078       {
47079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47080       };
47081     }
47082   }
47083
47084   jresult = (void *)result;
47085   return jresult;
47086 }
47087
47088
47089 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBufferImage__SWIG_0() {
47090   void * jresult ;
47091   Dali::FrameBufferImage *result = 0 ;
47092
47093   {
47094     try {
47095       result = (Dali::FrameBufferImage *)new Dali::FrameBufferImage();
47096     } catch (std::out_of_range& e) {
47097       {
47098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47099       };
47100     } catch (std::exception& e) {
47101       {
47102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47103       };
47104     } catch (Dali::DaliException e) {
47105       {
47106         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47107       };
47108     } catch (...) {
47109       {
47110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47111       };
47112     }
47113   }
47114
47115   jresult = (void *)result;
47116   return jresult;
47117 }
47118
47119
47120 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_0(unsigned int jarg1, unsigned int jarg2, int jarg3, int jarg4) {
47121   void * jresult ;
47122   unsigned int arg1 ;
47123   unsigned int arg2 ;
47124   Dali::Pixel::Format arg3 ;
47125   Dali::RenderBuffer::Format arg4 ;
47126   Dali::FrameBufferImage result;
47127
47128   arg1 = (unsigned int)jarg1;
47129   arg2 = (unsigned int)jarg2;
47130   arg3 = (Dali::Pixel::Format)jarg3;
47131   arg4 = (Dali::RenderBuffer::Format)jarg4;
47132   {
47133     try {
47134       result = Dali::FrameBufferImage::New(arg1,arg2,arg3,arg4);
47135     } catch (std::out_of_range& e) {
47136       {
47137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47138       };
47139     } catch (std::exception& e) {
47140       {
47141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47142       };
47143     } catch (Dali::DaliException e) {
47144       {
47145         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47146       };
47147     } catch (...) {
47148       {
47149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47150       };
47151     }
47152   }
47153
47154   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47155   return jresult;
47156 }
47157
47158
47159 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_1(unsigned int jarg1, unsigned int jarg2, int jarg3) {
47160   void * jresult ;
47161   unsigned int arg1 ;
47162   unsigned int arg2 ;
47163   Dali::Pixel::Format arg3 ;
47164   Dali::FrameBufferImage result;
47165
47166   arg1 = (unsigned int)jarg1;
47167   arg2 = (unsigned int)jarg2;
47168   arg3 = (Dali::Pixel::Format)jarg3;
47169   {
47170     try {
47171       result = Dali::FrameBufferImage::New(arg1,arg2,arg3);
47172     } catch (std::out_of_range& e) {
47173       {
47174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47175       };
47176     } catch (std::exception& e) {
47177       {
47178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47179       };
47180     } catch (Dali::DaliException e) {
47181       {
47182         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47183       };
47184     } catch (...) {
47185       {
47186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47187       };
47188     }
47189   }
47190
47191   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47192   return jresult;
47193 }
47194
47195
47196 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
47197   void * jresult ;
47198   unsigned int arg1 ;
47199   unsigned int arg2 ;
47200   Dali::FrameBufferImage result;
47201
47202   arg1 = (unsigned int)jarg1;
47203   arg2 = (unsigned int)jarg2;
47204   {
47205     try {
47206       result = Dali::FrameBufferImage::New(arg1,arg2);
47207     } catch (std::out_of_range& e) {
47208       {
47209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47210       };
47211     } catch (std::exception& e) {
47212       {
47213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47214       };
47215     } catch (Dali::DaliException e) {
47216       {
47217         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47218       };
47219     } catch (...) {
47220       {
47221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47222       };
47223     }
47224   }
47225
47226   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47227   return jresult;
47228 }
47229
47230
47231 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_3(unsigned int jarg1) {
47232   void * jresult ;
47233   unsigned int arg1 ;
47234   Dali::FrameBufferImage result;
47235
47236   arg1 = (unsigned int)jarg1;
47237   {
47238     try {
47239       result = Dali::FrameBufferImage::New(arg1);
47240     } catch (std::out_of_range& e) {
47241       {
47242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47243       };
47244     } catch (std::exception& e) {
47245       {
47246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47247       };
47248     } catch (Dali::DaliException e) {
47249       {
47250         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47251       };
47252     } catch (...) {
47253       {
47254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47255       };
47256     }
47257   }
47258
47259   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47260   return jresult;
47261 }
47262
47263
47264 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_4() {
47265   void * jresult ;
47266   Dali::FrameBufferImage result;
47267
47268   {
47269     try {
47270       result = Dali::FrameBufferImage::New();
47271     } catch (std::out_of_range& e) {
47272       {
47273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47274       };
47275     } catch (std::exception& e) {
47276       {
47277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47278       };
47279     } catch (Dali::DaliException e) {
47280       {
47281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47282       };
47283     } catch (...) {
47284       {
47285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47286       };
47287     }
47288   }
47289
47290   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47291   return jresult;
47292 }
47293
47294
47295 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_5(void * jarg1) {
47296   void * jresult ;
47297   Dali::NativeImageInterface *arg1 = 0 ;
47298   Dali::FrameBufferImage result;
47299
47300   arg1 = (Dali::NativeImageInterface *)jarg1;
47301   if (!arg1) {
47302     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImageInterface & type is null", 0);
47303     return 0;
47304   }
47305   {
47306     try {
47307       result = Dali::FrameBufferImage::New(*arg1);
47308     } catch (std::out_of_range& e) {
47309       {
47310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47311       };
47312     } catch (std::exception& e) {
47313       {
47314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47315       };
47316     } catch (Dali::DaliException e) {
47317       {
47318         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47319       };
47320     } catch (...) {
47321       {
47322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47323       };
47324     }
47325   }
47326
47327   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47328   return jresult;
47329 }
47330
47331
47332 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_DownCast(void * jarg1) {
47333   void * jresult ;
47334   Dali::BaseHandle arg1 ;
47335   Dali::BaseHandle *argp1 ;
47336   Dali::FrameBufferImage result;
47337
47338   argp1 = (Dali::BaseHandle *)jarg1;
47339   if (!argp1) {
47340     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
47341     return 0;
47342   }
47343   arg1 = *argp1;
47344   {
47345     try {
47346       result = Dali::FrameBufferImage::DownCast(arg1);
47347     } catch (std::out_of_range& e) {
47348       {
47349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47350       };
47351     } catch (std::exception& e) {
47352       {
47353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47354       };
47355     } catch (Dali::DaliException e) {
47356       {
47357         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47358       };
47359     } catch (...) {
47360       {
47361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47362       };
47363     }
47364   }
47365
47366   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47367   return jresult;
47368 }
47369
47370
47371 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBufferImage(void * jarg1) {
47372   Dali::FrameBufferImage *arg1 = (Dali::FrameBufferImage *) 0 ;
47373
47374   arg1 = (Dali::FrameBufferImage *)jarg1;
47375   {
47376     try {
47377       delete arg1;
47378     } catch (std::out_of_range& e) {
47379       {
47380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47381       };
47382     } catch (std::exception& e) {
47383       {
47384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47385       };
47386     } catch (Dali::DaliException e) {
47387       {
47388         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47389       };
47390     } catch (...) {
47391       {
47392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47393       };
47394     }
47395   }
47396
47397 }
47398
47399
47400 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBufferImage__SWIG_1(void * jarg1) {
47401   void * jresult ;
47402   Dali::FrameBufferImage *arg1 = 0 ;
47403   Dali::FrameBufferImage *result = 0 ;
47404
47405   arg1 = (Dali::FrameBufferImage *)jarg1;
47406   if (!arg1) {
47407     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBufferImage const & type is null", 0);
47408     return 0;
47409   }
47410   {
47411     try {
47412       result = (Dali::FrameBufferImage *)new Dali::FrameBufferImage((Dali::FrameBufferImage const &)*arg1);
47413     } catch (std::out_of_range& e) {
47414       {
47415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47416       };
47417     } catch (std::exception& e) {
47418       {
47419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47420       };
47421     } catch (Dali::DaliException e) {
47422       {
47423         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47424       };
47425     } catch (...) {
47426       {
47427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47428       };
47429     }
47430   }
47431
47432   jresult = (void *)result;
47433   return jresult;
47434 }
47435
47436
47437 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_Assign(void * jarg1, void * jarg2) {
47438   void * jresult ;
47439   Dali::FrameBufferImage *arg1 = (Dali::FrameBufferImage *) 0 ;
47440   Dali::FrameBufferImage *arg2 = 0 ;
47441   Dali::FrameBufferImage *result = 0 ;
47442
47443   arg1 = (Dali::FrameBufferImage *)jarg1;
47444   arg2 = (Dali::FrameBufferImage *)jarg2;
47445   if (!arg2) {
47446     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBufferImage const & type is null", 0);
47447     return 0;
47448   }
47449   {
47450     try {
47451       result = (Dali::FrameBufferImage *) &(arg1)->operator =((Dali::FrameBufferImage const &)*arg2);
47452     } catch (std::out_of_range& e) {
47453       {
47454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47455       };
47456     } catch (std::exception& e) {
47457       {
47458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47459       };
47460     } catch (Dali::DaliException e) {
47461       {
47462         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47463       };
47464     } catch (...) {
47465       {
47466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47467       };
47468     }
47469   }
47470
47471   jresult = (void *)result;
47472   return jresult;
47473 }
47474
47475
47476 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NinePatchImage__SWIG_0() {
47477   void * jresult ;
47478   Dali::NinePatchImage *result = 0 ;
47479
47480   {
47481     try {
47482       result = (Dali::NinePatchImage *)new Dali::NinePatchImage();
47483     } catch (std::out_of_range& e) {
47484       {
47485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47486       };
47487     } catch (std::exception& e) {
47488       {
47489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47490       };
47491     } catch (Dali::DaliException e) {
47492       {
47493         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47494       };
47495     } catch (...) {
47496       {
47497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47498       };
47499     }
47500   }
47501
47502   jresult = (void *)result;
47503   return jresult;
47504 }
47505
47506
47507 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_New(char * jarg1) {
47508   void * jresult ;
47509   std::string *arg1 = 0 ;
47510   Dali::NinePatchImage result;
47511
47512   if (!jarg1) {
47513     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
47514     return 0;
47515   }
47516   std::string arg1_str(jarg1);
47517   arg1 = &arg1_str;
47518   {
47519     try {
47520       result = Dali::NinePatchImage::New((std::string const &)*arg1);
47521     } catch (std::out_of_range& e) {
47522       {
47523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47524       };
47525     } catch (std::exception& e) {
47526       {
47527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47528       };
47529     } catch (Dali::DaliException e) {
47530       {
47531         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47532       };
47533     } catch (...) {
47534       {
47535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47536       };
47537     }
47538   }
47539
47540   jresult = new Dali::NinePatchImage((const Dali::NinePatchImage &)result);
47541
47542   //argout typemap for const std::string&
47543
47544   return jresult;
47545 }
47546
47547
47548 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_DownCast(void * jarg1) {
47549   void * jresult ;
47550   Dali::BaseHandle arg1 ;
47551   Dali::BaseHandle *argp1 ;
47552   Dali::NinePatchImage result;
47553
47554   argp1 = (Dali::BaseHandle *)jarg1;
47555   if (!argp1) {
47556     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
47557     return 0;
47558   }
47559   arg1 = *argp1;
47560   {
47561     try {
47562       result = Dali::NinePatchImage::DownCast(arg1);
47563     } catch (std::out_of_range& e) {
47564       {
47565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47566       };
47567     } catch (std::exception& e) {
47568       {
47569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47570       };
47571     } catch (Dali::DaliException e) {
47572       {
47573         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47574       };
47575     } catch (...) {
47576       {
47577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47578       };
47579     }
47580   }
47581
47582   jresult = new Dali::NinePatchImage((const Dali::NinePatchImage &)result);
47583   return jresult;
47584 }
47585
47586
47587 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_NinePatchImage(void * jarg1) {
47588   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47589
47590   arg1 = (Dali::NinePatchImage *)jarg1;
47591   {
47592     try {
47593       delete arg1;
47594     } catch (std::out_of_range& e) {
47595       {
47596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47597       };
47598     } catch (std::exception& e) {
47599       {
47600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47601       };
47602     } catch (Dali::DaliException e) {
47603       {
47604         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47605       };
47606     } catch (...) {
47607       {
47608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47609       };
47610     }
47611   }
47612
47613 }
47614
47615
47616 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NinePatchImage__SWIG_1(void * jarg1) {
47617   void * jresult ;
47618   Dali::NinePatchImage *arg1 = 0 ;
47619   Dali::NinePatchImage *result = 0 ;
47620
47621   arg1 = (Dali::NinePatchImage *)jarg1;
47622   if (!arg1) {
47623     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NinePatchImage const & type is null", 0);
47624     return 0;
47625   }
47626   {
47627     try {
47628       result = (Dali::NinePatchImage *)new Dali::NinePatchImage((Dali::NinePatchImage const &)*arg1);
47629     } catch (std::out_of_range& e) {
47630       {
47631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47632       };
47633     } catch (std::exception& e) {
47634       {
47635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47636       };
47637     } catch (Dali::DaliException e) {
47638       {
47639         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47640       };
47641     } catch (...) {
47642       {
47643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47644       };
47645     }
47646   }
47647
47648   jresult = (void *)result;
47649   return jresult;
47650 }
47651
47652
47653 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_Assign(void * jarg1, void * jarg2) {
47654   void * jresult ;
47655   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47656   Dali::NinePatchImage *arg2 = 0 ;
47657   Dali::NinePatchImage *result = 0 ;
47658
47659   arg1 = (Dali::NinePatchImage *)jarg1;
47660   arg2 = (Dali::NinePatchImage *)jarg2;
47661   if (!arg2) {
47662     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NinePatchImage const & type is null", 0);
47663     return 0;
47664   }
47665   {
47666     try {
47667       result = (Dali::NinePatchImage *) &(arg1)->operator =((Dali::NinePatchImage const &)*arg2);
47668     } catch (std::out_of_range& e) {
47669       {
47670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47671       };
47672     } catch (std::exception& e) {
47673       {
47674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47675       };
47676     } catch (Dali::DaliException e) {
47677       {
47678         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47679       };
47680     } catch (...) {
47681       {
47682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47683       };
47684     }
47685   }
47686
47687   jresult = (void *)result;
47688   return jresult;
47689 }
47690
47691
47692 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchBorders(void * jarg1) {
47693   void * jresult ;
47694   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47695   Dali::Vector4 result;
47696
47697   arg1 = (Dali::NinePatchImage *)jarg1;
47698   {
47699     try {
47700       result = (arg1)->GetStretchBorders();
47701     } catch (std::out_of_range& e) {
47702       {
47703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47704       };
47705     } catch (std::exception& e) {
47706       {
47707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47708       };
47709     } catch (Dali::DaliException e) {
47710       {
47711         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47712       };
47713     } catch (...) {
47714       {
47715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47716       };
47717     }
47718   }
47719
47720   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
47721   return jresult;
47722 }
47723
47724
47725 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchPixelsX(void * jarg1) {
47726   void * jresult ;
47727   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47728   Dali::NinePatchImage::StretchRanges *result = 0 ;
47729
47730   arg1 = (Dali::NinePatchImage *)jarg1;
47731   {
47732     try {
47733       result = (Dali::NinePatchImage::StretchRanges *) &(arg1)->GetStretchPixelsX();
47734     } catch (std::out_of_range& e) {
47735       {
47736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47737       };
47738     } catch (std::exception& e) {
47739       {
47740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47741       };
47742     } catch (Dali::DaliException e) {
47743       {
47744         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47745       };
47746     } catch (...) {
47747       {
47748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47749       };
47750     }
47751   }
47752
47753   jresult = (void *)result;
47754   return jresult;
47755 }
47756
47757
47758 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchPixelsY(void * jarg1) {
47759   void * jresult ;
47760   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47761   Dali::NinePatchImage::StretchRanges *result = 0 ;
47762
47763   arg1 = (Dali::NinePatchImage *)jarg1;
47764   {
47765     try {
47766       result = (Dali::NinePatchImage::StretchRanges *) &(arg1)->GetStretchPixelsY();
47767     } catch (std::out_of_range& e) {
47768       {
47769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47770       };
47771     } catch (std::exception& e) {
47772       {
47773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47774       };
47775     } catch (Dali::DaliException e) {
47776       {
47777         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47778       };
47779     } catch (...) {
47780       {
47781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47782       };
47783     }
47784   }
47785
47786   jresult = (void *)result;
47787   return jresult;
47788 }
47789
47790
47791 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetChildRectangle(void * jarg1) {
47792   void * jresult ;
47793   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47794   Dali::Rect< int > result;
47795
47796   arg1 = (Dali::NinePatchImage *)jarg1;
47797   {
47798     try {
47799       result = (arg1)->GetChildRectangle();
47800     } catch (std::out_of_range& e) {
47801       {
47802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47803       };
47804     } catch (std::exception& e) {
47805       {
47806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47807       };
47808     } catch (Dali::DaliException e) {
47809       {
47810         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47811       };
47812     } catch (...) {
47813       {
47814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47815       };
47816     }
47817   }
47818
47819   jresult = new Dali::Rect< int >((const Dali::Rect< int > &)result);
47820   return jresult;
47821 }
47822
47823
47824 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_CreateCroppedBufferImage(void * jarg1) {
47825   void * jresult ;
47826   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47827   Dali::BufferImage result;
47828
47829   arg1 = (Dali::NinePatchImage *)jarg1;
47830   {
47831     try {
47832       result = (arg1)->CreateCroppedBufferImage();
47833     } catch (std::out_of_range& e) {
47834       {
47835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47836       };
47837     } catch (std::exception& e) {
47838       {
47839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47840       };
47841     } catch (Dali::DaliException e) {
47842       {
47843         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47844       };
47845     } catch (...) {
47846       {
47847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47848       };
47849     }
47850   }
47851
47852   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
47853   return jresult;
47854 }
47855
47856
47857 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NinePatchImage_IsNinePatchUrl(char * jarg1) {
47858   unsigned int jresult ;
47859   std::string *arg1 = 0 ;
47860   bool result;
47861
47862   if (!jarg1) {
47863     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
47864     return 0;
47865   }
47866   std::string arg1_str(jarg1);
47867   arg1 = &arg1_str;
47868   {
47869     try {
47870       result = (bool)Dali::NinePatchImage::IsNinePatchUrl((std::string const &)*arg1);
47871     } catch (std::out_of_range& e) {
47872       {
47873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47874       };
47875     } catch (std::exception& e) {
47876       {
47877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47878       };
47879     } catch (Dali::DaliException e) {
47880       {
47881         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47882       };
47883     } catch (...) {
47884       {
47885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47886       };
47887     }
47888   }
47889
47890   jresult = result;
47891
47892   //argout typemap for const std::string&
47893
47894   return jresult;
47895 }
47896
47897
47898 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TYPE_get() {
47899   int jresult ;
47900   int result;
47901
47902   result = (int)Dali::CameraActor::Property::TYPE;
47903   jresult = (int)result;
47904   return jresult;
47905 }
47906
47907
47908 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MODE_get() {
47909   int jresult ;
47910   int result;
47911
47912   result = (int)Dali::CameraActor::Property::PROJECTION_MODE;
47913   jresult = (int)result;
47914   return jresult;
47915 }
47916
47917
47918 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FIELD_OF_VIEW_get() {
47919   int jresult ;
47920   int result;
47921
47922   result = (int)Dali::CameraActor::Property::FIELD_OF_VIEW;
47923   jresult = (int)result;
47924   return jresult;
47925 }
47926
47927
47928 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_ASPECT_RATIO_get() {
47929   int jresult ;
47930   int result;
47931
47932   result = (int)Dali::CameraActor::Property::ASPECT_RATIO;
47933   jresult = (int)result;
47934   return jresult;
47935 }
47936
47937
47938 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_NEAR_PLANE_DISTANCE_get() {
47939   int jresult ;
47940   int result;
47941
47942   result = (int)Dali::CameraActor::Property::NEAR_PLANE_DISTANCE;
47943   jresult = (int)result;
47944   return jresult;
47945 }
47946
47947
47948 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FAR_PLANE_DISTANCE_get() {
47949   int jresult ;
47950   int result;
47951
47952   result = (int)Dali::CameraActor::Property::FAR_PLANE_DISTANCE;
47953   jresult = (int)result;
47954   return jresult;
47955 }
47956
47957
47958 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_LEFT_PLANE_DISTANCE_get() {
47959   int jresult ;
47960   int result;
47961
47962   result = (int)Dali::CameraActor::Property::LEFT_PLANE_DISTANCE;
47963   jresult = (int)result;
47964   return jresult;
47965 }
47966
47967
47968 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_RIGHT_PLANE_DISTANCE_get() {
47969   int jresult ;
47970   int result;
47971
47972   result = (int)Dali::CameraActor::Property::RIGHT_PLANE_DISTANCE;
47973   jresult = (int)result;
47974   return jresult;
47975 }
47976
47977
47978 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TOP_PLANE_DISTANCE_get() {
47979   int jresult ;
47980   int result;
47981
47982   result = (int)Dali::CameraActor::Property::TOP_PLANE_DISTANCE;
47983   jresult = (int)result;
47984   return jresult;
47985 }
47986
47987
47988 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_BOTTOM_PLANE_DISTANCE_get() {
47989   int jresult ;
47990   int result;
47991
47992   result = (int)Dali::CameraActor::Property::BOTTOM_PLANE_DISTANCE;
47993   jresult = (int)result;
47994   return jresult;
47995 }
47996
47997
47998 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TARGET_POSITION_get() {
47999   int jresult ;
48000   int result;
48001
48002   result = (int)Dali::CameraActor::Property::TARGET_POSITION;
48003   jresult = (int)result;
48004   return jresult;
48005 }
48006
48007
48008 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MATRIX_get() {
48009   int jresult ;
48010   int result;
48011
48012   result = (int)Dali::CameraActor::Property::PROJECTION_MATRIX;
48013   jresult = (int)result;
48014   return jresult;
48015 }
48016
48017
48018 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_VIEW_MATRIX_get() {
48019   int jresult ;
48020   int result;
48021
48022   result = (int)Dali::CameraActor::Property::VIEW_MATRIX;
48023   jresult = (int)result;
48024   return jresult;
48025 }
48026
48027
48028 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_INVERT_Y_AXIS_get() {
48029   int jresult ;
48030   int result;
48031
48032   result = (int)Dali::CameraActor::Property::INVERT_Y_AXIS;
48033   jresult = (int)result;
48034   return jresult;
48035 }
48036
48037
48038 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor_Property() {
48039   void * jresult ;
48040   Dali::CameraActor::Property *result = 0 ;
48041
48042   {
48043     try {
48044       result = (Dali::CameraActor::Property *)new Dali::CameraActor::Property();
48045     } catch (std::out_of_range& e) {
48046       {
48047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48048       };
48049     } catch (std::exception& e) {
48050       {
48051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48052       };
48053     } catch (Dali::DaliException e) {
48054       {
48055         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48056       };
48057     } catch (...) {
48058       {
48059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48060       };
48061     }
48062   }
48063
48064   jresult = (void *)result;
48065   return jresult;
48066 }
48067
48068
48069 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor_Property(void * jarg1) {
48070   Dali::CameraActor::Property *arg1 = (Dali::CameraActor::Property *) 0 ;
48071
48072   arg1 = (Dali::CameraActor::Property *)jarg1;
48073   {
48074     try {
48075       delete arg1;
48076     } catch (std::out_of_range& e) {
48077       {
48078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48079       };
48080     } catch (std::exception& e) {
48081       {
48082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48083       };
48084     } catch (Dali::DaliException e) {
48085       {
48086         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48087       };
48088     } catch (...) {
48089       {
48090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48091       };
48092     }
48093   }
48094
48095 }
48096
48097
48098 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_0() {
48099   void * jresult ;
48100   Dali::CameraActor *result = 0 ;
48101
48102   {
48103     try {
48104       result = (Dali::CameraActor *)new Dali::CameraActor();
48105     } catch (std::out_of_range& e) {
48106       {
48107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48108       };
48109     } catch (std::exception& e) {
48110       {
48111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48112       };
48113     } catch (Dali::DaliException e) {
48114       {
48115         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48116       };
48117     } catch (...) {
48118       {
48119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48120       };
48121     }
48122   }
48123
48124   jresult = (void *)result;
48125   return jresult;
48126 }
48127
48128
48129 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_0() {
48130   void * jresult ;
48131   Dali::CameraActor result;
48132
48133   {
48134     try {
48135       result = Dali::CameraActor::New();
48136     } catch (std::out_of_range& e) {
48137       {
48138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48139       };
48140     } catch (std::exception& e) {
48141       {
48142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48143       };
48144     } catch (Dali::DaliException e) {
48145       {
48146         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48147       };
48148     } catch (...) {
48149       {
48150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48151       };
48152     }
48153   }
48154
48155   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
48156   return jresult;
48157 }
48158
48159
48160 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_1(void * jarg1) {
48161   void * jresult ;
48162   Dali::Size *arg1 = 0 ;
48163   Dali::CameraActor result;
48164
48165   arg1 = (Dali::Size *)jarg1;
48166   if (!arg1) {
48167     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
48168     return 0;
48169   }
48170   {
48171     try {
48172       result = Dali::CameraActor::New((Dali::Vector2 const &)*arg1);
48173     } catch (std::out_of_range& e) {
48174       {
48175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48176       };
48177     } catch (std::exception& e) {
48178       {
48179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48180       };
48181     } catch (Dali::DaliException e) {
48182       {
48183         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48184       };
48185     } catch (...) {
48186       {
48187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48188       };
48189     }
48190   }
48191
48192   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
48193   return jresult;
48194 }
48195
48196
48197 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_DownCast(void * jarg1) {
48198   void * jresult ;
48199   Dali::BaseHandle arg1 ;
48200   Dali::BaseHandle *argp1 ;
48201   Dali::CameraActor result;
48202
48203   argp1 = (Dali::BaseHandle *)jarg1;
48204   if (!argp1) {
48205     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
48206     return 0;
48207   }
48208   arg1 = *argp1;
48209   {
48210     try {
48211       result = Dali::CameraActor::DownCast(arg1);
48212     } catch (std::out_of_range& e) {
48213       {
48214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48215       };
48216     } catch (std::exception& e) {
48217       {
48218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48219       };
48220     } catch (Dali::DaliException e) {
48221       {
48222         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48223       };
48224     } catch (...) {
48225       {
48226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48227       };
48228     }
48229   }
48230
48231   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
48232   return jresult;
48233 }
48234
48235
48236 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor(void * jarg1) {
48237   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48238
48239   arg1 = (Dali::CameraActor *)jarg1;
48240   {
48241     try {
48242       delete arg1;
48243     } catch (std::out_of_range& e) {
48244       {
48245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48246       };
48247     } catch (std::exception& e) {
48248       {
48249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48250       };
48251     } catch (Dali::DaliException e) {
48252       {
48253         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48254       };
48255     } catch (...) {
48256       {
48257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48258       };
48259     }
48260   }
48261
48262 }
48263
48264
48265 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_1(void * jarg1) {
48266   void * jresult ;
48267   Dali::CameraActor *arg1 = 0 ;
48268   Dali::CameraActor *result = 0 ;
48269
48270   arg1 = (Dali::CameraActor *)jarg1;
48271   if (!arg1) {
48272     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
48273     return 0;
48274   }
48275   {
48276     try {
48277       result = (Dali::CameraActor *)new Dali::CameraActor((Dali::CameraActor const &)*arg1);
48278     } catch (std::out_of_range& e) {
48279       {
48280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48281       };
48282     } catch (std::exception& e) {
48283       {
48284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48285       };
48286     } catch (Dali::DaliException e) {
48287       {
48288         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48289       };
48290     } catch (...) {
48291       {
48292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48293       };
48294     }
48295   }
48296
48297   jresult = (void *)result;
48298   return jresult;
48299 }
48300
48301
48302 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_Assign(void * jarg1, void * jarg2) {
48303   void * jresult ;
48304   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48305   Dali::CameraActor *arg2 = 0 ;
48306   Dali::CameraActor *result = 0 ;
48307
48308   arg1 = (Dali::CameraActor *)jarg1;
48309   arg2 = (Dali::CameraActor *)jarg2;
48310   if (!arg2) {
48311     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
48312     return 0;
48313   }
48314   {
48315     try {
48316       result = (Dali::CameraActor *) &(arg1)->operator =((Dali::CameraActor const &)*arg2);
48317     } catch (std::out_of_range& e) {
48318       {
48319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48320       };
48321     } catch (std::exception& e) {
48322       {
48323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48324       };
48325     } catch (Dali::DaliException e) {
48326       {
48327         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48328       };
48329     } catch (...) {
48330       {
48331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48332       };
48333     }
48334   }
48335
48336   jresult = (void *)result;
48337   return jresult;
48338 }
48339
48340
48341 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetType(void * jarg1, int jarg2) {
48342   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48343   Dali::Camera::Type arg2 ;
48344
48345   arg1 = (Dali::CameraActor *)jarg1;
48346   arg2 = (Dali::Camera::Type)jarg2;
48347   {
48348     try {
48349       (arg1)->SetType(arg2);
48350     } catch (std::out_of_range& e) {
48351       {
48352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48353       };
48354     } catch (std::exception& e) {
48355       {
48356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48357       };
48358     } catch (Dali::DaliException e) {
48359       {
48360         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48361       };
48362     } catch (...) {
48363       {
48364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48365       };
48366     }
48367   }
48368
48369 }
48370
48371
48372 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetType(void * jarg1) {
48373   int jresult ;
48374   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48375   Dali::Camera::Type result;
48376
48377   arg1 = (Dali::CameraActor *)jarg1;
48378   {
48379     try {
48380       result = (Dali::Camera::Type)((Dali::CameraActor const *)arg1)->GetType();
48381     } catch (std::out_of_range& e) {
48382       {
48383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48384       };
48385     } catch (std::exception& e) {
48386       {
48387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48388       };
48389     } catch (Dali::DaliException e) {
48390       {
48391         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48392       };
48393     } catch (...) {
48394       {
48395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48396       };
48397     }
48398   }
48399
48400   jresult = (int)result;
48401   return jresult;
48402 }
48403
48404
48405 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetProjectionMode(void * jarg1, int jarg2) {
48406   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48407   Dali::Camera::ProjectionMode arg2 ;
48408
48409   arg1 = (Dali::CameraActor *)jarg1;
48410   arg2 = (Dali::Camera::ProjectionMode)jarg2;
48411   {
48412     try {
48413       (arg1)->SetProjectionMode(arg2);
48414     } catch (std::out_of_range& e) {
48415       {
48416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48417       };
48418     } catch (std::exception& e) {
48419       {
48420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48421       };
48422     } catch (Dali::DaliException e) {
48423       {
48424         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48425       };
48426     } catch (...) {
48427       {
48428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48429       };
48430     }
48431   }
48432
48433 }
48434
48435
48436 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetProjectionMode(void * jarg1) {
48437   int jresult ;
48438   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48439   Dali::Camera::ProjectionMode result;
48440
48441   arg1 = (Dali::CameraActor *)jarg1;
48442   {
48443     try {
48444       result = (Dali::Camera::ProjectionMode)((Dali::CameraActor const *)arg1)->GetProjectionMode();
48445     } catch (std::out_of_range& e) {
48446       {
48447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48448       };
48449     } catch (std::exception& e) {
48450       {
48451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48452       };
48453     } catch (Dali::DaliException e) {
48454       {
48455         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48456       };
48457     } catch (...) {
48458       {
48459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48460       };
48461     }
48462   }
48463
48464   jresult = (int)result;
48465   return jresult;
48466 }
48467
48468
48469 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFieldOfView(void * jarg1, float jarg2) {
48470   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48471   float arg2 ;
48472
48473   arg1 = (Dali::CameraActor *)jarg1;
48474   arg2 = (float)jarg2;
48475   {
48476     try {
48477       (arg1)->SetFieldOfView(arg2);
48478     } catch (std::out_of_range& e) {
48479       {
48480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48481       };
48482     } catch (std::exception& e) {
48483       {
48484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48485       };
48486     } catch (Dali::DaliException e) {
48487       {
48488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48489       };
48490     } catch (...) {
48491       {
48492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48493       };
48494     }
48495   }
48496
48497 }
48498
48499
48500 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFieldOfView(void * jarg1) {
48501   float jresult ;
48502   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48503   float result;
48504
48505   arg1 = (Dali::CameraActor *)jarg1;
48506   {
48507     try {
48508       result = (float)(arg1)->GetFieldOfView();
48509     } catch (std::out_of_range& e) {
48510       {
48511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48512       };
48513     } catch (std::exception& e) {
48514       {
48515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48516       };
48517     } catch (Dali::DaliException e) {
48518       {
48519         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48520       };
48521     } catch (...) {
48522       {
48523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48524       };
48525     }
48526   }
48527
48528   jresult = result;
48529   return jresult;
48530 }
48531
48532
48533 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetAspectRatio(void * jarg1, float jarg2) {
48534   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48535   float arg2 ;
48536
48537   arg1 = (Dali::CameraActor *)jarg1;
48538   arg2 = (float)jarg2;
48539   {
48540     try {
48541       (arg1)->SetAspectRatio(arg2);
48542     } catch (std::out_of_range& e) {
48543       {
48544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48545       };
48546     } catch (std::exception& e) {
48547       {
48548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48549       };
48550     } catch (Dali::DaliException e) {
48551       {
48552         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48553       };
48554     } catch (...) {
48555       {
48556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48557       };
48558     }
48559   }
48560
48561 }
48562
48563
48564 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetAspectRatio(void * jarg1) {
48565   float jresult ;
48566   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48567   float result;
48568
48569   arg1 = (Dali::CameraActor *)jarg1;
48570   {
48571     try {
48572       result = (float)(arg1)->GetAspectRatio();
48573     } catch (std::out_of_range& e) {
48574       {
48575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48576       };
48577     } catch (std::exception& e) {
48578       {
48579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48580       };
48581     } catch (Dali::DaliException e) {
48582       {
48583         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48584       };
48585     } catch (...) {
48586       {
48587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48588       };
48589     }
48590   }
48591
48592   jresult = result;
48593   return jresult;
48594 }
48595
48596
48597 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetNearClippingPlane(void * jarg1, float jarg2) {
48598   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48599   float arg2 ;
48600
48601   arg1 = (Dali::CameraActor *)jarg1;
48602   arg2 = (float)jarg2;
48603   {
48604     try {
48605       (arg1)->SetNearClippingPlane(arg2);
48606     } catch (std::out_of_range& e) {
48607       {
48608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48609       };
48610     } catch (std::exception& e) {
48611       {
48612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48613       };
48614     } catch (Dali::DaliException e) {
48615       {
48616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48617       };
48618     } catch (...) {
48619       {
48620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48621       };
48622     }
48623   }
48624
48625 }
48626
48627
48628 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetNearClippingPlane(void * jarg1) {
48629   float jresult ;
48630   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48631   float result;
48632
48633   arg1 = (Dali::CameraActor *)jarg1;
48634   {
48635     try {
48636       result = (float)(arg1)->GetNearClippingPlane();
48637     } catch (std::out_of_range& e) {
48638       {
48639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48640       };
48641     } catch (std::exception& e) {
48642       {
48643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48644       };
48645     } catch (Dali::DaliException e) {
48646       {
48647         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48648       };
48649     } catch (...) {
48650       {
48651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48652       };
48653     }
48654   }
48655
48656   jresult = result;
48657   return jresult;
48658 }
48659
48660
48661 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFarClippingPlane(void * jarg1, float jarg2) {
48662   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48663   float arg2 ;
48664
48665   arg1 = (Dali::CameraActor *)jarg1;
48666   arg2 = (float)jarg2;
48667   {
48668     try {
48669       (arg1)->SetFarClippingPlane(arg2);
48670     } catch (std::out_of_range& e) {
48671       {
48672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48673       };
48674     } catch (std::exception& e) {
48675       {
48676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48677       };
48678     } catch (Dali::DaliException e) {
48679       {
48680         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48681       };
48682     } catch (...) {
48683       {
48684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48685       };
48686     }
48687   }
48688
48689 }
48690
48691
48692 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFarClippingPlane(void * jarg1) {
48693   float jresult ;
48694   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48695   float result;
48696
48697   arg1 = (Dali::CameraActor *)jarg1;
48698   {
48699     try {
48700       result = (float)(arg1)->GetFarClippingPlane();
48701     } catch (std::out_of_range& e) {
48702       {
48703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48704       };
48705     } catch (std::exception& e) {
48706       {
48707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48708       };
48709     } catch (Dali::DaliException e) {
48710       {
48711         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48712       };
48713     } catch (...) {
48714       {
48715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48716       };
48717     }
48718   }
48719
48720   jresult = result;
48721   return jresult;
48722 }
48723
48724
48725 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetTargetPosition(void * jarg1, void * jarg2) {
48726   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48727   Dali::Vector3 *arg2 = 0 ;
48728
48729   arg1 = (Dali::CameraActor *)jarg1;
48730   arg2 = (Dali::Vector3 *)jarg2;
48731   if (!arg2) {
48732     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
48733     return ;
48734   }
48735   {
48736     try {
48737       (arg1)->SetTargetPosition((Dali::Vector3 const &)*arg2);
48738     } catch (std::out_of_range& e) {
48739       {
48740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48741       };
48742     } catch (std::exception& e) {
48743       {
48744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48745       };
48746     } catch (Dali::DaliException e) {
48747       {
48748         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48749       };
48750     } catch (...) {
48751       {
48752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48753       };
48754     }
48755   }
48756
48757 }
48758
48759
48760 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_GetTargetPosition(void * jarg1) {
48761   void * jresult ;
48762   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48763   Dali::Vector3 result;
48764
48765   arg1 = (Dali::CameraActor *)jarg1;
48766   {
48767     try {
48768       result = ((Dali::CameraActor const *)arg1)->GetTargetPosition();
48769     } catch (std::out_of_range& e) {
48770       {
48771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48772       };
48773     } catch (std::exception& e) {
48774       {
48775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48776       };
48777     } catch (Dali::DaliException e) {
48778       {
48779         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48780       };
48781     } catch (...) {
48782       {
48783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48784       };
48785     }
48786   }
48787
48788   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
48789   return jresult;
48790 }
48791
48792
48793 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetInvertYAxis(void * jarg1, unsigned int jarg2) {
48794   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48795   bool arg2 ;
48796
48797   arg1 = (Dali::CameraActor *)jarg1;
48798   arg2 = jarg2 ? true : false;
48799   {
48800     try {
48801       (arg1)->SetInvertYAxis(arg2);
48802     } catch (std::out_of_range& e) {
48803       {
48804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48805       };
48806     } catch (std::exception& e) {
48807       {
48808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48809       };
48810     } catch (Dali::DaliException e) {
48811       {
48812         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48813       };
48814     } catch (...) {
48815       {
48816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48817       };
48818     }
48819   }
48820
48821 }
48822
48823
48824 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CameraActor_GetInvertYAxis(void * jarg1) {
48825   unsigned int jresult ;
48826   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48827   bool result;
48828
48829   arg1 = (Dali::CameraActor *)jarg1;
48830   {
48831     try {
48832       result = (bool)(arg1)->GetInvertYAxis();
48833     } catch (std::out_of_range& e) {
48834       {
48835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48836       };
48837     } catch (std::exception& e) {
48838       {
48839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48840       };
48841     } catch (Dali::DaliException e) {
48842       {
48843         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48844       };
48845     } catch (...) {
48846       {
48847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48848       };
48849     }
48850   }
48851
48852   jresult = result;
48853   return jresult;
48854 }
48855
48856
48857 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetPerspectiveProjection(void * jarg1, void * jarg2) {
48858   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48859   Dali::Size *arg2 = 0 ;
48860
48861   arg1 = (Dali::CameraActor *)jarg1;
48862   arg2 = (Dali::Size *)jarg2;
48863   if (!arg2) {
48864     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
48865     return ;
48866   }
48867   {
48868     try {
48869       (arg1)->SetPerspectiveProjection((Dali::Size const &)*arg2);
48870     } catch (std::out_of_range& e) {
48871       {
48872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48873       };
48874     } catch (std::exception& e) {
48875       {
48876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48877       };
48878     } catch (Dali::DaliException e) {
48879       {
48880         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48881       };
48882     } catch (...) {
48883       {
48884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48885       };
48886     }
48887   }
48888
48889 }
48890
48891
48892 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_0(void * jarg1, void * jarg2) {
48893   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48894   Dali::Size *arg2 = 0 ;
48895
48896   arg1 = (Dali::CameraActor *)jarg1;
48897   arg2 = (Dali::Size *)jarg2;
48898   if (!arg2) {
48899     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
48900     return ;
48901   }
48902   {
48903     try {
48904       (arg1)->SetOrthographicProjection((Dali::Size const &)*arg2);
48905     } catch (std::out_of_range& e) {
48906       {
48907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48908       };
48909     } catch (std::exception& e) {
48910       {
48911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48912       };
48913     } catch (Dali::DaliException e) {
48914       {
48915         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48916       };
48917     } catch (...) {
48918       {
48919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48920       };
48921     }
48922   }
48923
48924 }
48925
48926
48927 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, float jarg6, float jarg7) {
48928   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48929   float arg2 ;
48930   float arg3 ;
48931   float arg4 ;
48932   float arg5 ;
48933   float arg6 ;
48934   float arg7 ;
48935
48936   arg1 = (Dali::CameraActor *)jarg1;
48937   arg2 = (float)jarg2;
48938   arg3 = (float)jarg3;
48939   arg4 = (float)jarg4;
48940   arg5 = (float)jarg5;
48941   arg6 = (float)jarg6;
48942   arg7 = (float)jarg7;
48943   {
48944     try {
48945       (arg1)->SetOrthographicProjection(arg2,arg3,arg4,arg5,arg6,arg7);
48946     } catch (std::out_of_range& e) {
48947       {
48948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48949       };
48950     } catch (std::exception& e) {
48951       {
48952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48953       };
48954     } catch (Dali::DaliException e) {
48955       {
48956         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48957       };
48958     } catch (...) {
48959       {
48960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48961       };
48962     }
48963   }
48964
48965 }
48966
48967
48968 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_0() {
48969   void * jresult ;
48970   std::pair< std::string,Dali::Property::Value > *result = 0 ;
48971
48972   {
48973     try {
48974       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >();
48975     } catch (std::out_of_range& e) {
48976       {
48977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48978       };
48979     } catch (std::exception& e) {
48980       {
48981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48982       };
48983     } catch (Dali::DaliException e) {
48984       {
48985         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48986       };
48987     } catch (...) {
48988       {
48989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48990       };
48991     }
48992   }
48993
48994   jresult = (void *)result;
48995   return jresult;
48996 }
48997
48998
48999 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_1(char * jarg1, void * jarg2) {
49000   void * jresult ;
49001   std::string arg1 ;
49002   Dali::Property::Value arg2 ;
49003   Dali::Property::Value *argp2 ;
49004   std::pair< std::string,Dali::Property::Value > *result = 0 ;
49005
49006   if (!jarg1) {
49007     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
49008     return 0;
49009   }
49010   (&arg1)->assign(jarg1);
49011   argp2 = (Dali::Property::Value *)jarg2;
49012   if (!argp2) {
49013     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
49014     return 0;
49015   }
49016   arg2 = *argp2;
49017   {
49018     try {
49019       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >(arg1,arg2);
49020     } catch (std::out_of_range& e) {
49021       {
49022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49023       };
49024     } catch (std::exception& e) {
49025       {
49026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49027       };
49028     } catch (Dali::DaliException e) {
49029       {
49030         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49031       };
49032     } catch (...) {
49033       {
49034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49035       };
49036     }
49037   }
49038
49039   jresult = (void *)result;
49040   return jresult;
49041 }
49042
49043
49044 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_2(void * jarg1) {
49045   void * jresult ;
49046   std::pair< std::string,Dali::Property::Value > *arg1 = 0 ;
49047   std::pair< std::string,Dali::Property::Value > *result = 0 ;
49048
49049   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49050   if (!arg1) {
49051     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< std::string,Dali::Property::Value > const & type is null", 0);
49052     return 0;
49053   }
49054   {
49055     try {
49056       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);
49057     } catch (std::out_of_range& e) {
49058       {
49059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49060       };
49061     } catch (std::exception& e) {
49062       {
49063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49064       };
49065     } catch (Dali::DaliException e) {
49066       {
49067         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49068       };
49069     } catch (...) {
49070       {
49071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49072       };
49073     }
49074   }
49075
49076   jresult = (void *)result;
49077   return jresult;
49078 }
49079
49080
49081 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_first_set(void * jarg1, char * jarg2) {
49082   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
49083   std::string *arg2 = 0 ;
49084
49085   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49086   if (!jarg2) {
49087     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
49088     return ;
49089   }
49090   std::string arg2_str(jarg2);
49091   arg2 = &arg2_str;
49092   if (arg1) (arg1)->first = *arg2;
49093
49094   //argout typemap for const std::string&
49095
49096 }
49097
49098
49099 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_StringValuePair_first_get(void * jarg1) {
49100   char * jresult ;
49101   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
49102   std::string *result = 0 ;
49103
49104   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49105   result = (std::string *) & ((arg1)->first);
49106   jresult = SWIG_csharp_string_callback(result->c_str());
49107   return jresult;
49108 }
49109
49110
49111 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_second_set(void * jarg1, void * jarg2) {
49112   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
49113   Dali::Property::Value *arg2 = (Dali::Property::Value *) 0 ;
49114
49115   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49116   arg2 = (Dali::Property::Value *)jarg2;
49117   if (arg1) (arg1)->second = *arg2;
49118 }
49119
49120
49121 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StringValuePair_second_get(void * jarg1) {
49122   void * jresult ;
49123   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
49124   Dali::Property::Value *result = 0 ;
49125
49126   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49127   result = (Dali::Property::Value *)& ((arg1)->second);
49128   jresult = (void *)result;
49129   return jresult;
49130 }
49131
49132
49133 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StringValuePair(void * jarg1) {
49134   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
49135
49136   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49137   {
49138     try {
49139       delete arg1;
49140     } catch (std::out_of_range& e) {
49141       {
49142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49143       };
49144     } catch (std::exception& e) {
49145       {
49146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49147       };
49148     } catch (Dali::DaliException e) {
49149       {
49150         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49151       };
49152     } catch (...) {
49153       {
49154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49155       };
49156     }
49157   }
49158
49159 }
49160
49161
49162 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Clear(void * jarg1) {
49163   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49164
49165   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49166   {
49167     try {
49168       (arg1)->clear();
49169     } catch (std::out_of_range& e) {
49170       {
49171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49172       };
49173     } catch (std::exception& e) {
49174       {
49175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49176       };
49177     } catch (Dali::DaliException e) {
49178       {
49179         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49180       };
49181     } catch (...) {
49182       {
49183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49184       };
49185     }
49186   }
49187
49188 }
49189
49190
49191 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Add(void * jarg1, void * jarg2) {
49192   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49193   Dali::TouchPoint *arg2 = 0 ;
49194
49195   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49196   arg2 = (Dali::TouchPoint *)jarg2;
49197   if (!arg2) {
49198     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
49199     return ;
49200   }
49201   {
49202     try {
49203       (arg1)->push_back((Dali::TouchPoint const &)*arg2);
49204     } catch (std::out_of_range& e) {
49205       {
49206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49207       };
49208     } catch (std::exception& e) {
49209       {
49210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49211       };
49212     } catch (Dali::DaliException e) {
49213       {
49214         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49215       };
49216     } catch (...) {
49217       {
49218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49219       };
49220     }
49221   }
49222
49223 }
49224
49225
49226 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_size(void * jarg1) {
49227   unsigned long jresult ;
49228   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49229   std::vector< Dali::TouchPoint >::size_type result;
49230
49231   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49232   {
49233     try {
49234       result = ((std::vector< Dali::TouchPoint > const *)arg1)->size();
49235     } catch (std::out_of_range& e) {
49236       {
49237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49238       };
49239     } catch (std::exception& e) {
49240       {
49241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49242       };
49243     } catch (Dali::DaliException e) {
49244       {
49245         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49246       };
49247     } catch (...) {
49248       {
49249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49250       };
49251     }
49252   }
49253
49254   jresult = (unsigned long)result;
49255   return jresult;
49256 }
49257
49258
49259 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_capacity(void * jarg1) {
49260   unsigned long jresult ;
49261   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49262   std::vector< Dali::TouchPoint >::size_type result;
49263
49264   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49265   {
49266     try {
49267       result = ((std::vector< Dali::TouchPoint > const *)arg1)->capacity();
49268     } catch (std::out_of_range& e) {
49269       {
49270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49271       };
49272     } catch (std::exception& e) {
49273       {
49274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49275       };
49276     } catch (Dali::DaliException e) {
49277       {
49278         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49279       };
49280     } catch (...) {
49281       {
49282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49283       };
49284     }
49285   }
49286
49287   jresult = (unsigned long)result;
49288   return jresult;
49289 }
49290
49291
49292 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_reserve(void * jarg1, unsigned long jarg2) {
49293   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49294   std::vector< Dali::TouchPoint >::size_type arg2 ;
49295
49296   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49297   arg2 = (std::vector< Dali::TouchPoint >::size_type)jarg2;
49298   {
49299     try {
49300       (arg1)->reserve(arg2);
49301     } catch (std::out_of_range& e) {
49302       {
49303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49304       };
49305     } catch (std::exception& e) {
49306       {
49307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49308       };
49309     } catch (Dali::DaliException e) {
49310       {
49311         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49312       };
49313     } catch (...) {
49314       {
49315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49316       };
49317     }
49318   }
49319
49320 }
49321
49322
49323 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_0() {
49324   void * jresult ;
49325   std::vector< Dali::TouchPoint > *result = 0 ;
49326
49327   {
49328     try {
49329       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >();
49330     } catch (std::out_of_range& e) {
49331       {
49332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49333       };
49334     } catch (std::exception& e) {
49335       {
49336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49337       };
49338     } catch (Dali::DaliException e) {
49339       {
49340         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49341       };
49342     } catch (...) {
49343       {
49344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49345       };
49346     }
49347   }
49348
49349   jresult = (void *)result;
49350   return jresult;
49351 }
49352
49353
49354 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_1(void * jarg1) {
49355   void * jresult ;
49356   std::vector< Dali::TouchPoint > *arg1 = 0 ;
49357   std::vector< Dali::TouchPoint > *result = 0 ;
49358
49359   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49360   if (!arg1) {
49361     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
49362     return 0;
49363   }
49364   {
49365     try {
49366       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >((std::vector< Dali::TouchPoint > const &)*arg1);
49367     } catch (std::out_of_range& e) {
49368       {
49369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49370       };
49371     } catch (std::exception& e) {
49372       {
49373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49374       };
49375     } catch (Dali::DaliException e) {
49376       {
49377         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49378       };
49379     } catch (...) {
49380       {
49381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49382       };
49383     }
49384   }
49385
49386   jresult = (void *)result;
49387   return jresult;
49388 }
49389
49390
49391 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_2(int jarg1) {
49392   void * jresult ;
49393   int arg1 ;
49394   std::vector< Dali::TouchPoint > *result = 0 ;
49395
49396   arg1 = (int)jarg1;
49397   {
49398     try {
49399       try {
49400         result = (std::vector< Dali::TouchPoint > *)new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(arg1);
49401       }
49402       catch(std::out_of_range &_e) {
49403         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49404         return 0;
49405       }
49406
49407     } catch (std::out_of_range& e) {
49408       {
49409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49410       };
49411     } catch (std::exception& e) {
49412       {
49413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49414       };
49415     } catch (Dali::DaliException e) {
49416       {
49417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49418       };
49419     } catch (...) {
49420       {
49421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49422       };
49423     }
49424   }
49425
49426   jresult = (void *)result;
49427   return jresult;
49428 }
49429
49430
49431 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitemcopy(void * jarg1, int jarg2) {
49432   void * jresult ;
49433   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49434   int arg2 ;
49435   SwigValueWrapper< Dali::TouchPoint > result;
49436
49437   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49438   arg2 = (int)jarg2;
49439   {
49440     try {
49441       try {
49442         result = std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(arg1,arg2);
49443       }
49444       catch(std::out_of_range &_e) {
49445         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49446         return 0;
49447       }
49448
49449     } catch (std::out_of_range& e) {
49450       {
49451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49452       };
49453     } catch (std::exception& e) {
49454       {
49455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49456       };
49457     } catch (Dali::DaliException e) {
49458       {
49459         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49460       };
49461     } catch (...) {
49462       {
49463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49464       };
49465     }
49466   }
49467
49468   jresult = new Dali::TouchPoint((const Dali::TouchPoint &)result);
49469   return jresult;
49470 }
49471
49472
49473 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitem(void * jarg1, int jarg2) {
49474   void * jresult ;
49475   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49476   int arg2 ;
49477   Dali::TouchPoint *result = 0 ;
49478
49479   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49480   arg2 = (int)jarg2;
49481   {
49482     try {
49483       try {
49484         result = (Dali::TouchPoint *) &std_vector_Sl_Dali_TouchPoint_Sg__getitem(arg1,arg2);
49485       }
49486       catch(std::out_of_range &_e) {
49487         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49488         return 0;
49489       }
49490
49491     } catch (std::out_of_range& e) {
49492       {
49493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49494       };
49495     } catch (std::exception& e) {
49496       {
49497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49498       };
49499     } catch (Dali::DaliException e) {
49500       {
49501         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49502       };
49503     } catch (...) {
49504       {
49505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49506       };
49507     }
49508   }
49509
49510   jresult = (void *)result;
49511   return jresult;
49512 }
49513
49514
49515 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
49516   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49517   int arg2 ;
49518   Dali::TouchPoint *arg3 = 0 ;
49519
49520   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49521   arg2 = (int)jarg2;
49522   arg3 = (Dali::TouchPoint *)jarg3;
49523   if (!arg3) {
49524     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
49525     return ;
49526   }
49527   {
49528     try {
49529       try {
49530         std_vector_Sl_Dali_TouchPoint_Sg__setitem(arg1,arg2,(Dali::TouchPoint const &)*arg3);
49531       }
49532       catch(std::out_of_range &_e) {
49533         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49534         return ;
49535       }
49536
49537     } catch (std::out_of_range& e) {
49538       {
49539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49540       };
49541     } catch (std::exception& e) {
49542       {
49543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49544       };
49545     } catch (Dali::DaliException e) {
49546       {
49547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49548       };
49549     } catch (...) {
49550       {
49551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49552       };
49553     }
49554   }
49555
49556 }
49557
49558
49559 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_AddRange(void * jarg1, void * jarg2) {
49560   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49561   std::vector< Dali::TouchPoint > *arg2 = 0 ;
49562
49563   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49564   arg2 = (std::vector< Dali::TouchPoint > *)jarg2;
49565   if (!arg2) {
49566     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
49567     return ;
49568   }
49569   {
49570     try {
49571       std_vector_Sl_Dali_TouchPoint_Sg__AddRange(arg1,(std::vector< Dali::TouchPoint > const &)*arg2);
49572     } catch (std::out_of_range& e) {
49573       {
49574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49575       };
49576     } catch (std::exception& e) {
49577       {
49578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49579       };
49580     } catch (Dali::DaliException e) {
49581       {
49582         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49583       };
49584     } catch (...) {
49585       {
49586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49587       };
49588     }
49589   }
49590
49591 }
49592
49593
49594 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
49595   void * jresult ;
49596   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49597   int arg2 ;
49598   int arg3 ;
49599   std::vector< Dali::TouchPoint > *result = 0 ;
49600
49601   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49602   arg2 = (int)jarg2;
49603   arg3 = (int)jarg3;
49604   {
49605     try {
49606       try {
49607         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__GetRange(arg1,arg2,arg3);
49608       }
49609       catch(std::out_of_range &_e) {
49610         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49611         return 0;
49612       }
49613       catch(std::invalid_argument &_e) {
49614         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
49615         return 0;
49616       }
49617
49618     } catch (std::out_of_range& e) {
49619       {
49620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49621       };
49622     } catch (std::exception& e) {
49623       {
49624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49625       };
49626     } catch (Dali::DaliException e) {
49627       {
49628         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49629       };
49630     } catch (...) {
49631       {
49632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49633       };
49634     }
49635   }
49636
49637   jresult = (void *)result;
49638   return jresult;
49639 }
49640
49641
49642 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
49643   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49644   int arg2 ;
49645   Dali::TouchPoint *arg3 = 0 ;
49646
49647   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49648   arg2 = (int)jarg2;
49649   arg3 = (Dali::TouchPoint *)jarg3;
49650   if (!arg3) {
49651     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
49652     return ;
49653   }
49654   {
49655     try {
49656       try {
49657         std_vector_Sl_Dali_TouchPoint_Sg__Insert(arg1,arg2,(Dali::TouchPoint const &)*arg3);
49658       }
49659       catch(std::out_of_range &_e) {
49660         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49661         return ;
49662       }
49663
49664     } catch (std::out_of_range& e) {
49665       {
49666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49667       };
49668     } catch (std::exception& e) {
49669       {
49670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49671       };
49672     } catch (Dali::DaliException e) {
49673       {
49674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49675       };
49676     } catch (...) {
49677       {
49678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49679       };
49680     }
49681   }
49682
49683 }
49684
49685
49686 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
49687   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49688   int arg2 ;
49689   std::vector< Dali::TouchPoint > *arg3 = 0 ;
49690
49691   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49692   arg2 = (int)jarg2;
49693   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
49694   if (!arg3) {
49695     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
49696     return ;
49697   }
49698   {
49699     try {
49700       try {
49701         std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
49702       }
49703       catch(std::out_of_range &_e) {
49704         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49705         return ;
49706       }
49707
49708     } catch (std::out_of_range& e) {
49709       {
49710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49711       };
49712     } catch (std::exception& e) {
49713       {
49714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49715       };
49716     } catch (Dali::DaliException e) {
49717       {
49718         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49719       };
49720     } catch (...) {
49721       {
49722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49723       };
49724     }
49725   }
49726
49727 }
49728
49729
49730 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveAt(void * jarg1, int jarg2) {
49731   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49732   int arg2 ;
49733
49734   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49735   arg2 = (int)jarg2;
49736   {
49737     try {
49738       try {
49739         std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(arg1,arg2);
49740       }
49741       catch(std::out_of_range &_e) {
49742         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49743         return ;
49744       }
49745
49746     } catch (std::out_of_range& e) {
49747       {
49748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49749       };
49750     } catch (std::exception& e) {
49751       {
49752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49753       };
49754     } catch (Dali::DaliException e) {
49755       {
49756         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49757       };
49758     } catch (...) {
49759       {
49760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49761       };
49762     }
49763   }
49764
49765 }
49766
49767
49768 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
49769   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49770   int arg2 ;
49771   int arg3 ;
49772
49773   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49774   arg2 = (int)jarg2;
49775   arg3 = (int)jarg3;
49776   {
49777     try {
49778       try {
49779         std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(arg1,arg2,arg3);
49780       }
49781       catch(std::out_of_range &_e) {
49782         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49783         return ;
49784       }
49785       catch(std::invalid_argument &_e) {
49786         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
49787         return ;
49788       }
49789
49790     } catch (std::out_of_range& e) {
49791       {
49792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49793       };
49794     } catch (std::exception& e) {
49795       {
49796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49797       };
49798     } catch (Dali::DaliException e) {
49799       {
49800         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49801       };
49802     } catch (...) {
49803       {
49804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49805       };
49806     }
49807   }
49808
49809 }
49810
49811
49812 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_Repeat(void * jarg1, int jarg2) {
49813   void * jresult ;
49814   Dali::TouchPoint *arg1 = 0 ;
49815   int arg2 ;
49816   std::vector< Dali::TouchPoint > *result = 0 ;
49817
49818   arg1 = (Dali::TouchPoint *)jarg1;
49819   if (!arg1) {
49820     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
49821     return 0;
49822   }
49823   arg2 = (int)jarg2;
49824   {
49825     try {
49826       try {
49827         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__Repeat((Dali::TouchPoint const &)*arg1,arg2);
49828       }
49829       catch(std::out_of_range &_e) {
49830         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49831         return 0;
49832       }
49833
49834     } catch (std::out_of_range& e) {
49835       {
49836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49837       };
49838     } catch (std::exception& e) {
49839       {
49840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49841       };
49842     } catch (Dali::DaliException e) {
49843       {
49844         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49845       };
49846     } catch (...) {
49847       {
49848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49849       };
49850     }
49851   }
49852
49853   jresult = (void *)result;
49854   return jresult;
49855 }
49856
49857
49858 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_0(void * jarg1) {
49859   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49860
49861   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49862   {
49863     try {
49864       std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(arg1);
49865     } catch (std::out_of_range& e) {
49866       {
49867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49868       };
49869     } catch (std::exception& e) {
49870       {
49871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49872       };
49873     } catch (Dali::DaliException e) {
49874       {
49875         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49876       };
49877     } catch (...) {
49878       {
49879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49880       };
49881     }
49882   }
49883
49884 }
49885
49886
49887 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
49888   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49889   int arg2 ;
49890   int arg3 ;
49891
49892   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49893   arg2 = (int)jarg2;
49894   arg3 = (int)jarg3;
49895   {
49896     try {
49897       try {
49898         std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
49899       }
49900       catch(std::out_of_range &_e) {
49901         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49902         return ;
49903       }
49904       catch(std::invalid_argument &_e) {
49905         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
49906         return ;
49907       }
49908
49909     } catch (std::out_of_range& e) {
49910       {
49911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49912       };
49913     } catch (std::exception& e) {
49914       {
49915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49916       };
49917     } catch (Dali::DaliException e) {
49918       {
49919         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49920       };
49921     } catch (...) {
49922       {
49923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49924       };
49925     }
49926   }
49927
49928 }
49929
49930
49931 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
49932   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49933   int arg2 ;
49934   std::vector< Dali::TouchPoint > *arg3 = 0 ;
49935
49936   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49937   arg2 = (int)jarg2;
49938   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
49939   if (!arg3) {
49940     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
49941     return ;
49942   }
49943   {
49944     try {
49945       try {
49946         std_vector_Sl_Dali_TouchPoint_Sg__SetRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
49947       }
49948       catch(std::out_of_range &_e) {
49949         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49950         return ;
49951       }
49952
49953     } catch (std::out_of_range& e) {
49954       {
49955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49956       };
49957     } catch (std::exception& e) {
49958       {
49959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49960       };
49961     } catch (Dali::DaliException e) {
49962       {
49963         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49964       };
49965     } catch (...) {
49966       {
49967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49968       };
49969     }
49970   }
49971
49972 }
49973
49974
49975 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPointContainer(void * jarg1) {
49976   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49977
49978   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49979   {
49980     try {
49981       delete arg1;
49982     } catch (std::out_of_range& e) {
49983       {
49984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49985       };
49986     } catch (std::exception& e) {
49987       {
49988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49989       };
49990     } catch (Dali::DaliException e) {
49991       {
49992         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49993       };
49994     } catch (...) {
49995       {
49996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49997       };
49998     }
49999   }
50000
50001 }
50002
50003
50004 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_0() {
50005   void * jresult ;
50006   Dali::Rect< int > *result = 0 ;
50007
50008   {
50009     try {
50010       result = (Dali::Rect< int > *)new Dali::Rect< int >();
50011     } catch (std::out_of_range& e) {
50012       {
50013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50014       };
50015     } catch (std::exception& e) {
50016       {
50017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50018       };
50019     } catch (Dali::DaliException e) {
50020       {
50021         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50022       };
50023     } catch (...) {
50024       {
50025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50026       };
50027     }
50028   }
50029
50030   jresult = (void *)result;
50031   return jresult;
50032 }
50033
50034
50035 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_1(int jarg1, int jarg2, int jarg3, int jarg4) {
50036   void * jresult ;
50037   int arg1 ;
50038   int arg2 ;
50039   int arg3 ;
50040   int arg4 ;
50041   Dali::Rect< int > *result = 0 ;
50042
50043   arg1 = (int)jarg1;
50044   arg2 = (int)jarg2;
50045   arg3 = (int)jarg3;
50046   arg4 = (int)jarg4;
50047   {
50048     try {
50049       result = (Dali::Rect< int > *)new Dali::Rect< int >(arg1,arg2,arg3,arg4);
50050     } catch (std::out_of_range& e) {
50051       {
50052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50053       };
50054     } catch (std::exception& e) {
50055       {
50056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50057       };
50058     } catch (Dali::DaliException e) {
50059       {
50060         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50061       };
50062     } catch (...) {
50063       {
50064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50065       };
50066     }
50067   }
50068
50069   jresult = (void *)result;
50070   return jresult;
50071 }
50072
50073
50074 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_2(void * jarg1) {
50075   void * jresult ;
50076   Dali::Rect< int > *arg1 = 0 ;
50077   Dali::Rect< int > *result = 0 ;
50078
50079   arg1 = (Dali::Rect< int > *)jarg1;
50080   if (!arg1) {
50081     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
50082     return 0;
50083   }
50084   {
50085     try {
50086       result = (Dali::Rect< int > *)new Dali::Rect< int >((Dali::Rect< int > const &)*arg1);
50087     } catch (std::out_of_range& e) {
50088       {
50089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50090       };
50091     } catch (std::exception& e) {
50092       {
50093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50094       };
50095     } catch (Dali::DaliException e) {
50096       {
50097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50098       };
50099     } catch (...) {
50100       {
50101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50102       };
50103     }
50104   }
50105
50106   jresult = (void *)result;
50107   return jresult;
50108 }
50109
50110
50111 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rectangle_Assign(void * jarg1, void * jarg2) {
50112   void * jresult ;
50113   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50114   Dali::Rect< int > *arg2 = 0 ;
50115   Dali::Rect< int > *result = 0 ;
50116
50117   arg1 = (Dali::Rect< int > *)jarg1;
50118   arg2 = (Dali::Rect< int > *)jarg2;
50119   if (!arg2) {
50120     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
50121     return 0;
50122   }
50123   {
50124     try {
50125       result = (Dali::Rect< int > *) &(arg1)->operator =((Dali::Rect< int > const &)*arg2);
50126     } catch (std::out_of_range& e) {
50127       {
50128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50129       };
50130     } catch (std::exception& e) {
50131       {
50132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50133       };
50134     } catch (Dali::DaliException e) {
50135       {
50136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50137       };
50138     } catch (...) {
50139       {
50140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50141       };
50142     }
50143   }
50144
50145   jresult = (void *)result;
50146   return jresult;
50147 }
50148
50149
50150 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_Set(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
50151   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50152   int arg2 ;
50153   int arg3 ;
50154   int arg4 ;
50155   int arg5 ;
50156
50157   arg1 = (Dali::Rect< int > *)jarg1;
50158   arg2 = (int)jarg2;
50159   arg3 = (int)jarg3;
50160   arg4 = (int)jarg4;
50161   arg5 = (int)jarg5;
50162   {
50163     try {
50164       (arg1)->Set(arg2,arg3,arg4,arg5);
50165     } catch (std::out_of_range& e) {
50166       {
50167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50168       };
50169     } catch (std::exception& e) {
50170       {
50171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50172       };
50173     } catch (Dali::DaliException e) {
50174       {
50175         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50176       };
50177     } catch (...) {
50178       {
50179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50180       };
50181     }
50182   }
50183
50184 }
50185
50186
50187 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_IsEmpty(void * jarg1) {
50188   unsigned int jresult ;
50189   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50190   bool result;
50191
50192   arg1 = (Dali::Rect< int > *)jarg1;
50193   {
50194     try {
50195       result = (bool)((Dali::Rect< int > const *)arg1)->IsEmpty();
50196     } catch (std::out_of_range& e) {
50197       {
50198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50199       };
50200     } catch (std::exception& e) {
50201       {
50202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50203       };
50204     } catch (Dali::DaliException e) {
50205       {
50206         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50207       };
50208     } catch (...) {
50209       {
50210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50211       };
50212     }
50213   }
50214
50215   jresult = result;
50216   return jresult;
50217 }
50218
50219
50220 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Left(void * jarg1) {
50221   int jresult ;
50222   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50223   int result;
50224
50225   arg1 = (Dali::Rect< int > *)jarg1;
50226   {
50227     try {
50228       result = (int)((Dali::Rect< int > const *)arg1)->Left();
50229     } catch (std::out_of_range& e) {
50230       {
50231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50232       };
50233     } catch (std::exception& e) {
50234       {
50235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50236       };
50237     } catch (Dali::DaliException e) {
50238       {
50239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50240       };
50241     } catch (...) {
50242       {
50243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50244       };
50245     }
50246   }
50247
50248   jresult = result;
50249   return jresult;
50250 }
50251
50252
50253 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Right(void * jarg1) {
50254   int jresult ;
50255   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50256   int result;
50257
50258   arg1 = (Dali::Rect< int > *)jarg1;
50259   {
50260     try {
50261       result = (int)((Dali::Rect< int > const *)arg1)->Right();
50262     } catch (std::out_of_range& e) {
50263       {
50264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50265       };
50266     } catch (std::exception& e) {
50267       {
50268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50269       };
50270     } catch (Dali::DaliException e) {
50271       {
50272         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50273       };
50274     } catch (...) {
50275       {
50276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50277       };
50278     }
50279   }
50280
50281   jresult = result;
50282   return jresult;
50283 }
50284
50285
50286 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Top(void * jarg1) {
50287   int jresult ;
50288   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50289   int result;
50290
50291   arg1 = (Dali::Rect< int > *)jarg1;
50292   {
50293     try {
50294       result = (int)((Dali::Rect< int > const *)arg1)->Top();
50295     } catch (std::out_of_range& e) {
50296       {
50297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50298       };
50299     } catch (std::exception& e) {
50300       {
50301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50302       };
50303     } catch (Dali::DaliException e) {
50304       {
50305         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50306       };
50307     } catch (...) {
50308       {
50309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50310       };
50311     }
50312   }
50313
50314   jresult = result;
50315   return jresult;
50316 }
50317
50318
50319 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Bottom(void * jarg1) {
50320   int jresult ;
50321   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50322   int result;
50323
50324   arg1 = (Dali::Rect< int > *)jarg1;
50325   {
50326     try {
50327       result = (int)((Dali::Rect< int > const *)arg1)->Bottom();
50328     } catch (std::out_of_range& e) {
50329       {
50330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50331       };
50332     } catch (std::exception& e) {
50333       {
50334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50335       };
50336     } catch (Dali::DaliException e) {
50337       {
50338         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50339       };
50340     } catch (...) {
50341       {
50342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50343       };
50344     }
50345   }
50346
50347   jresult = result;
50348   return jresult;
50349 }
50350
50351
50352 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Area(void * jarg1) {
50353   int jresult ;
50354   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50355   int result;
50356
50357   arg1 = (Dali::Rect< int > *)jarg1;
50358   {
50359     try {
50360       result = (int)((Dali::Rect< int > const *)arg1)->Area();
50361     } catch (std::out_of_range& e) {
50362       {
50363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50364       };
50365     } catch (std::exception& e) {
50366       {
50367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50368       };
50369     } catch (Dali::DaliException e) {
50370       {
50371         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50372       };
50373     } catch (...) {
50374       {
50375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50376       };
50377     }
50378   }
50379
50380   jresult = result;
50381   return jresult;
50382 }
50383
50384
50385 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Intersects(void * jarg1, void * jarg2) {
50386   unsigned int jresult ;
50387   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50388   Dali::Rect< int > *arg2 = 0 ;
50389   bool result;
50390
50391   arg1 = (Dali::Rect< int > *)jarg1;
50392   arg2 = (Dali::Rect< int > *)jarg2;
50393   if (!arg2) {
50394     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
50395     return 0;
50396   }
50397   {
50398     try {
50399       result = (bool)((Dali::Rect< int > const *)arg1)->Intersects((Dali::Rect< int > const &)*arg2);
50400     } catch (std::out_of_range& e) {
50401       {
50402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50403       };
50404     } catch (std::exception& e) {
50405       {
50406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50407       };
50408     } catch (Dali::DaliException e) {
50409       {
50410         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50411       };
50412     } catch (...) {
50413       {
50414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50415       };
50416     }
50417   }
50418
50419   jresult = result;
50420   return jresult;
50421 }
50422
50423
50424 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Contains(void * jarg1, void * jarg2) {
50425   unsigned int jresult ;
50426   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50427   Dali::Rect< int > *arg2 = 0 ;
50428   bool result;
50429
50430   arg1 = (Dali::Rect< int > *)jarg1;
50431   arg2 = (Dali::Rect< int > *)jarg2;
50432   if (!arg2) {
50433     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
50434     return 0;
50435   }
50436   {
50437     try {
50438       result = (bool)((Dali::Rect< int > const *)arg1)->Contains((Dali::Rect< int > const &)*arg2);
50439     } catch (std::out_of_range& e) {
50440       {
50441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50442       };
50443     } catch (std::exception& e) {
50444       {
50445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50446       };
50447     } catch (Dali::DaliException e) {
50448       {
50449         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50450       };
50451     } catch (...) {
50452       {
50453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50454       };
50455     }
50456   }
50457
50458   jresult = result;
50459   return jresult;
50460 }
50461
50462
50463 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_x_set(void * jarg1, int jarg2) {
50464   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50465   int arg2 ;
50466
50467   arg1 = (Dali::Rect< int > *)jarg1;
50468   arg2 = (int)jarg2;
50469   if (arg1) (arg1)->x = arg2;
50470 }
50471
50472
50473 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_x_get(void * jarg1) {
50474   int jresult ;
50475   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50476   int result;
50477
50478   arg1 = (Dali::Rect< int > *)jarg1;
50479   result = (int) ((arg1)->x);
50480   jresult = result;
50481   return jresult;
50482 }
50483
50484
50485 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_left_set(void * jarg1, int jarg2) {
50486   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50487   int arg2 ;
50488
50489   arg1 = (Dali::Rect< int > *)jarg1;
50490   arg2 = (int)jarg2;
50491   if (arg1) (arg1)->left = arg2;
50492 }
50493
50494
50495 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_left_get(void * jarg1) {
50496   int jresult ;
50497   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50498   int result;
50499
50500   arg1 = (Dali::Rect< int > *)jarg1;
50501   result = (int) ((arg1)->left);
50502   jresult = result;
50503   return jresult;
50504 }
50505
50506
50507 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_y_set(void * jarg1, int jarg2) {
50508   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50509   int arg2 ;
50510
50511   arg1 = (Dali::Rect< int > *)jarg1;
50512   arg2 = (int)jarg2;
50513   if (arg1) (arg1)->y = arg2;
50514 }
50515
50516
50517 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_y_get(void * jarg1) {
50518   int jresult ;
50519   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50520   int result;
50521
50522   arg1 = (Dali::Rect< int > *)jarg1;
50523   result = (int) ((arg1)->y);
50524   jresult = result;
50525   return jresult;
50526 }
50527
50528
50529 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_right_set(void * jarg1, int jarg2) {
50530   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50531   int arg2 ;
50532
50533   arg1 = (Dali::Rect< int > *)jarg1;
50534   arg2 = (int)jarg2;
50535   if (arg1) (arg1)->right = arg2;
50536 }
50537
50538
50539 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_right_get(void * jarg1) {
50540   int jresult ;
50541   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50542   int result;
50543
50544   arg1 = (Dali::Rect< int > *)jarg1;
50545   result = (int) ((arg1)->right);
50546   jresult = result;
50547   return jresult;
50548 }
50549
50550
50551 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_width_set(void * jarg1, int jarg2) {
50552   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50553   int arg2 ;
50554
50555   arg1 = (Dali::Rect< int > *)jarg1;
50556   arg2 = (int)jarg2;
50557   if (arg1) (arg1)->width = arg2;
50558 }
50559
50560
50561 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_width_get(void * jarg1) {
50562   int jresult ;
50563   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50564   int result;
50565
50566   arg1 = (Dali::Rect< int > *)jarg1;
50567   result = (int) ((arg1)->width);
50568   jresult = result;
50569   return jresult;
50570 }
50571
50572
50573 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_bottom_set(void * jarg1, int jarg2) {
50574   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50575   int arg2 ;
50576
50577   arg1 = (Dali::Rect< int > *)jarg1;
50578   arg2 = (int)jarg2;
50579   if (arg1) (arg1)->bottom = arg2;
50580 }
50581
50582
50583 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_bottom_get(void * jarg1) {
50584   int jresult ;
50585   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50586   int result;
50587
50588   arg1 = (Dali::Rect< int > *)jarg1;
50589   result = (int) ((arg1)->bottom);
50590   jresult = result;
50591   return jresult;
50592 }
50593
50594
50595 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_height_set(void * jarg1, int jarg2) {
50596   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50597   int arg2 ;
50598
50599   arg1 = (Dali::Rect< int > *)jarg1;
50600   arg2 = (int)jarg2;
50601   if (arg1) (arg1)->height = arg2;
50602 }
50603
50604
50605 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_height_get(void * jarg1) {
50606   int jresult ;
50607   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50608   int result;
50609
50610   arg1 = (Dali::Rect< int > *)jarg1;
50611   result = (int) ((arg1)->height);
50612   jresult = result;
50613   return jresult;
50614 }
50615
50616
50617 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_top_set(void * jarg1, int jarg2) {
50618   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50619   int arg2 ;
50620
50621   arg1 = (Dali::Rect< int > *)jarg1;
50622   arg2 = (int)jarg2;
50623   if (arg1) (arg1)->top = arg2;
50624 }
50625
50626
50627 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_top_get(void * jarg1) {
50628   int jresult ;
50629   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50630   int result;
50631
50632   arg1 = (Dali::Rect< int > *)jarg1;
50633   result = (int) ((arg1)->top);
50634   jresult = result;
50635   return jresult;
50636 }
50637
50638
50639 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rectangle(void * jarg1) {
50640   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50641
50642   arg1 = (Dali::Rect< int > *)jarg1;
50643   {
50644     try {
50645       delete arg1;
50646     } catch (std::out_of_range& e) {
50647       {
50648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50649       };
50650     } catch (std::exception& e) {
50651       {
50652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50653       };
50654     } catch (Dali::DaliException e) {
50655       {
50656         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50657       };
50658     } catch (...) {
50659       {
50660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50661       };
50662     }
50663   }
50664
50665 }
50666
50667
50668 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_0() {
50669   void * jresult ;
50670   Dali::Rect< float > *result = 0 ;
50671
50672   {
50673     try {
50674       result = (Dali::Rect< float > *)new Dali::Rect< float >();
50675     } catch (std::out_of_range& e) {
50676       {
50677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50678       };
50679     } catch (std::exception& e) {
50680       {
50681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50682       };
50683     } catch (Dali::DaliException e) {
50684       {
50685         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50686       };
50687     } catch (...) {
50688       {
50689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50690       };
50691     }
50692   }
50693
50694   jresult = (void *)result;
50695   return jresult;
50696 }
50697
50698
50699 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
50700   void * jresult ;
50701   float arg1 ;
50702   float arg2 ;
50703   float arg3 ;
50704   float arg4 ;
50705   Dali::Rect< float > *result = 0 ;
50706
50707   arg1 = (float)jarg1;
50708   arg2 = (float)jarg2;
50709   arg3 = (float)jarg4;
50710   arg4 = (float)jarg3;
50711   {
50712     try {
50713       result = (Dali::Rect< float > *)new Dali::Rect< float >(arg1,arg2,arg3,arg4);
50714     } catch (std::out_of_range& e) {
50715       {
50716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50717       };
50718     } catch (std::exception& e) {
50719       {
50720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50721       };
50722     } catch (Dali::DaliException e) {
50723       {
50724         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50725       };
50726     } catch (...) {
50727       {
50728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50729       };
50730     }
50731   }
50732
50733   jresult = (void *)result;
50734   return jresult;
50735 }
50736
50737
50738 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_2(void * jarg1) {
50739   void * jresult ;
50740   Dali::Rect< float > *arg1 = 0 ;
50741   Dali::Rect< float > *result = 0 ;
50742
50743   arg1 = (Dali::Rect< float > *)jarg1;
50744   if (!arg1) {
50745     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
50746     return 0;
50747   }
50748   {
50749     try {
50750       result = (Dali::Rect< float > *)new Dali::Rect< float >((Dali::Rect< float > const &)*arg1);
50751     } catch (std::out_of_range& e) {
50752       {
50753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50754       };
50755     } catch (std::exception& e) {
50756       {
50757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50758       };
50759     } catch (Dali::DaliException e) {
50760       {
50761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50762       };
50763     } catch (...) {
50764       {
50765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50766       };
50767     }
50768   }
50769
50770   jresult = (void *)result;
50771   return jresult;
50772 }
50773
50774
50775 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PaddingType_Assign(void * jarg1, void * jarg2) {
50776   void * jresult ;
50777   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50778   Dali::Rect< float > *arg2 = 0 ;
50779   Dali::Rect< float > *result = 0 ;
50780
50781   arg1 = (Dali::Rect< float > *)jarg1;
50782   arg2 = (Dali::Rect< float > *)jarg2;
50783   if (!arg2) {
50784     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
50785     return 0;
50786   }
50787   {
50788     try {
50789       result = (Dali::Rect< float > *) &(arg1)->operator =((Dali::Rect< float > const &)*arg2);
50790     } catch (std::out_of_range& e) {
50791       {
50792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50793       };
50794     } catch (std::exception& e) {
50795       {
50796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50797       };
50798     } catch (Dali::DaliException e) {
50799       {
50800         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50801       };
50802     } catch (...) {
50803       {
50804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50805       };
50806     }
50807   }
50808
50809   jresult = (void *)result;
50810   return jresult;
50811 }
50812
50813
50814 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_Set(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
50815   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50816   float arg2 ;
50817   float arg3 ;
50818   float arg4 ;
50819   float arg5 ;
50820
50821   arg1 = (Dali::Rect< float > *)jarg1;
50822   arg2 = (float)jarg2;
50823   arg3 = (float)jarg3;
50824   arg4 = (float)jarg5;
50825   arg5 = (float)jarg4;
50826   {
50827     try {
50828       (arg1)->Set(arg2,arg3,arg4,arg5);
50829     } catch (std::out_of_range& e) {
50830       {
50831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50832       };
50833     } catch (std::exception& e) {
50834       {
50835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50836       };
50837     } catch (Dali::DaliException e) {
50838       {
50839         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50840       };
50841     } catch (...) {
50842       {
50843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50844       };
50845     }
50846   }
50847
50848 }
50849
50850
50851 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_left_set(void * jarg1, float jarg2) {
50852   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50853   float arg2 ;
50854
50855   arg1 = (Dali::Rect< float > *)jarg1;
50856   arg2 = (float)jarg2;
50857   if (arg1) (arg1)->left = arg2;
50858 }
50859
50860
50861 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_left_get(void * jarg1) {
50862   float jresult ;
50863   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50864   float result;
50865
50866   arg1 = (Dali::Rect< float > *)jarg1;
50867   result = (float) ((arg1)->left);
50868   jresult = result;
50869   return jresult;
50870 }
50871
50872
50873 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_start_set(void * jarg1, float jarg2) {
50874   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50875   float arg2 ;
50876
50877   arg1 = (Dali::Rect< float > *)jarg1;
50878   arg2 = (float)jarg2;
50879   if (arg1) (arg1)->left = arg2;
50880 }
50881
50882
50883 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_start_get(void * jarg1) {
50884   float jresult ;
50885   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50886   float result;
50887
50888   arg1 = (Dali::Rect< float > *)jarg1;
50889   result = (float) ((arg1)->left);
50890   jresult = result;
50891   return jresult;
50892 }
50893
50894
50895 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_right_set(void * jarg1, float jarg2) {
50896   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50897   float arg2 ;
50898
50899   arg1 = (Dali::Rect< float > *)jarg1;
50900   arg2 = (float)jarg2;
50901   if (arg1) (arg1)->right = arg2;
50902 }
50903
50904
50905 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_right_get(void * jarg1) {
50906   float jresult ;
50907   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50908   float result;
50909
50910   arg1 = (Dali::Rect< float > *)jarg1;
50911   result = (float) ((arg1)->right);
50912   jresult = result;
50913   return jresult;
50914 }
50915
50916
50917 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_end_set(void * jarg1, float jarg2) {
50918   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50919   float arg2 ;
50920
50921   arg1 = (Dali::Rect< float > *)jarg1;
50922   arg2 = (float)jarg2;
50923   if (arg1) (arg1)->right = arg2;
50924 }
50925
50926
50927 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_end_get(void * jarg1) {
50928   float jresult ;
50929   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50930   float result;
50931
50932   arg1 = (Dali::Rect< float > *)jarg1;
50933   result = (float) ((arg1)->right);
50934   jresult = result;
50935   return jresult;
50936 }
50937
50938
50939 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_bottom_set(void * jarg1, float jarg2) {
50940   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50941   float arg2 ;
50942
50943   arg1 = (Dali::Rect< float > *)jarg1;
50944   arg2 = (float)jarg2;
50945   if (arg1) (arg1)->bottom = arg2;
50946 }
50947
50948
50949 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_bottom_get(void * jarg1) {
50950   float jresult ;
50951   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50952   float result;
50953
50954   arg1 = (Dali::Rect< float > *)jarg1;
50955   result = (float) ((arg1)->bottom);
50956   jresult = result;
50957   return jresult;
50958 }
50959
50960
50961 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_top_set(void * jarg1, float jarg2) {
50962   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50963   float arg2 ;
50964
50965   arg1 = (Dali::Rect< float > *)jarg1;
50966   arg2 = (float)jarg2;
50967   if (arg1) (arg1)->top = arg2;
50968 }
50969
50970
50971 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_top_get(void * jarg1) {
50972   float jresult ;
50973   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50974   float result;
50975
50976   arg1 = (Dali::Rect< float > *)jarg1;
50977   result = (float) ((arg1)->top);
50978   jresult = result;
50979   return jresult;
50980 }
50981
50982
50983 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PaddingType(void * jarg1) {
50984   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50985
50986   arg1 = (Dali::Rect< float > *)jarg1;
50987   {
50988     try {
50989       delete arg1;
50990     } catch (std::out_of_range& e) {
50991       {
50992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50993       };
50994     } catch (std::exception& e) {
50995       {
50996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50997       };
50998     } catch (Dali::DaliException e) {
50999       {
51000         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51001       };
51002     } catch (...) {
51003       {
51004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51005       };
51006     }
51007   }
51008
51009 }
51010
51011
51012 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorInteger_BaseType_get() {
51013   int jresult ;
51014   int result;
51015
51016   result = (int)Dali::Vector< int >::BaseType;
51017   jresult = (int)result;
51018   return jresult;
51019 }
51020
51021
51022 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_0() {
51023   void * jresult ;
51024   Dali::Vector< int > *result = 0 ;
51025
51026   {
51027     try {
51028       result = (Dali::Vector< int > *)new Dali::Vector< int >();
51029     } catch (std::out_of_range& e) {
51030       {
51031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51032       };
51033     } catch (std::exception& e) {
51034       {
51035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51036       };
51037     } catch (Dali::DaliException e) {
51038       {
51039         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51040       };
51041     } catch (...) {
51042       {
51043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51044       };
51045     }
51046   }
51047
51048   jresult = (void *)result;
51049   return jresult;
51050 }
51051
51052
51053 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorInteger(void * jarg1) {
51054   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51055
51056   arg1 = (Dali::Vector< int > *)jarg1;
51057   {
51058     try {
51059       delete arg1;
51060     } catch (std::out_of_range& e) {
51061       {
51062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51063       };
51064     } catch (std::exception& e) {
51065       {
51066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51067       };
51068     } catch (Dali::DaliException e) {
51069       {
51070         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51071       };
51072     } catch (...) {
51073       {
51074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51075       };
51076     }
51077   }
51078
51079 }
51080
51081
51082 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_1(void * jarg1) {
51083   void * jresult ;
51084   Dali::Vector< int > *arg1 = 0 ;
51085   Dali::Vector< int > *result = 0 ;
51086
51087   arg1 = (Dali::Vector< int > *)jarg1;
51088   if (!arg1) {
51089     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
51090     return 0;
51091   }
51092   {
51093     try {
51094       result = (Dali::Vector< int > *)new Dali::Vector< int >((Dali::Vector< int > const &)*arg1);
51095     } catch (std::out_of_range& e) {
51096       {
51097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51098       };
51099     } catch (std::exception& e) {
51100       {
51101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51102       };
51103     } catch (Dali::DaliException e) {
51104       {
51105         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51106       };
51107     } catch (...) {
51108       {
51109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51110       };
51111     }
51112   }
51113
51114   jresult = (void *)result;
51115   return jresult;
51116 }
51117
51118
51119 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Assign(void * jarg1, void * jarg2) {
51120   void * jresult ;
51121   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51122   Dali::Vector< int > *arg2 = 0 ;
51123   Dali::Vector< int > *result = 0 ;
51124
51125   arg1 = (Dali::Vector< int > *)jarg1;
51126   arg2 = (Dali::Vector< int > *)jarg2;
51127   if (!arg2) {
51128     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
51129     return 0;
51130   }
51131   {
51132     try {
51133       result = (Dali::Vector< int > *) &(arg1)->operator =((Dali::Vector< int > const &)*arg2);
51134     } catch (std::out_of_range& e) {
51135       {
51136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51137       };
51138     } catch (std::exception& e) {
51139       {
51140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51141       };
51142     } catch (Dali::DaliException e) {
51143       {
51144         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51145       };
51146     } catch (...) {
51147       {
51148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51149       };
51150     }
51151   }
51152
51153   jresult = (void *)result;
51154   return jresult;
51155 }
51156
51157
51158 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Begin(void * jarg1) {
51159   void * jresult ;
51160   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51161   Dali::Vector< int >::Iterator result;
51162
51163   arg1 = (Dali::Vector< int > *)jarg1;
51164   {
51165     try {
51166       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->Begin();
51167     } catch (std::out_of_range& e) {
51168       {
51169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51170       };
51171     } catch (std::exception& e) {
51172       {
51173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51174       };
51175     } catch (Dali::DaliException e) {
51176       {
51177         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51178       };
51179     } catch (...) {
51180       {
51181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51182       };
51183     }
51184   }
51185
51186   jresult = (void *)result;
51187   return jresult;
51188 }
51189
51190
51191 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_End(void * jarg1) {
51192   void * jresult ;
51193   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51194   Dali::Vector< int >::Iterator result;
51195
51196   arg1 = (Dali::Vector< int > *)jarg1;
51197   {
51198     try {
51199       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->End();
51200     } catch (std::out_of_range& e) {
51201       {
51202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51203       };
51204     } catch (std::exception& e) {
51205       {
51206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51207       };
51208     } catch (Dali::DaliException e) {
51209       {
51210         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51211       };
51212     } catch (...) {
51213       {
51214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51215       };
51216     }
51217   }
51218
51219   jresult = (void *)result;
51220   return jresult;
51221 }
51222
51223
51224 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
51225   void * jresult ;
51226   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51227   Dali::Vector< int >::SizeType arg2 ;
51228   Dali::Vector< int >::ItemType *result = 0 ;
51229
51230   arg1 = (Dali::Vector< int > *)jarg1;
51231   arg2 = (Dali::Vector< int >::SizeType)jarg2;
51232   {
51233     try {
51234       result = (Dali::Vector< int >::ItemType *) &(arg1)->operator [](arg2);
51235     } catch (std::out_of_range& e) {
51236       {
51237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51238       };
51239     } catch (std::exception& e) {
51240       {
51241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51242       };
51243     } catch (Dali::DaliException e) {
51244       {
51245         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51246       };
51247     } catch (...) {
51248       {
51249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51250       };
51251     }
51252   }
51253
51254   jresult = (void *)result;
51255   return jresult;
51256 }
51257
51258
51259 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_PushBack(void * jarg1, int jarg2) {
51260   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51261   Dali::Vector< int >::ItemType *arg2 = 0 ;
51262   Dali::Vector< int >::ItemType temp2 ;
51263
51264   arg1 = (Dali::Vector< int > *)jarg1;
51265   temp2 = (Dali::Vector< int >::ItemType)jarg2;
51266   arg2 = &temp2;
51267   {
51268     try {
51269       (arg1)->PushBack((Dali::Vector< int >::ItemType const &)*arg2);
51270     } catch (std::out_of_range& e) {
51271       {
51272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51273       };
51274     } catch (std::exception& e) {
51275       {
51276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51277       };
51278     } catch (Dali::DaliException e) {
51279       {
51280         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51281       };
51282     } catch (...) {
51283       {
51284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51285       };
51286     }
51287   }
51288
51289 }
51290
51291
51292 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_0(void * jarg1, void * jarg2, int jarg3) {
51293   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51294   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51295   Dali::Vector< int >::ItemType *arg3 = 0 ;
51296   Dali::Vector< int >::ItemType temp3 ;
51297
51298   arg1 = (Dali::Vector< int > *)jarg1;
51299   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51300   temp3 = (Dali::Vector< int >::ItemType)jarg3;
51301   arg3 = &temp3;
51302   {
51303     try {
51304       (arg1)->Insert(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
51305     } catch (std::out_of_range& e) {
51306       {
51307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51308       };
51309     } catch (std::exception& e) {
51310       {
51311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51312       };
51313     } catch (Dali::DaliException e) {
51314       {
51315         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51316       };
51317     } catch (...) {
51318       {
51319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51320       };
51321     }
51322   }
51323
51324 }
51325
51326
51327 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
51328   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51329   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51330   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
51331   Dali::Vector< int >::Iterator arg4 = (Dali::Vector< int >::Iterator) 0 ;
51332
51333   arg1 = (Dali::Vector< int > *)jarg1;
51334   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51335   arg3 = (Dali::Vector< int >::Iterator)jarg3;
51336   arg4 = (Dali::Vector< int >::Iterator)jarg4;
51337   {
51338     try {
51339       (arg1)->Insert(arg2,arg3,arg4);
51340     } catch (std::out_of_range& e) {
51341       {
51342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51343       };
51344     } catch (std::exception& e) {
51345       {
51346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51347       };
51348     } catch (Dali::DaliException e) {
51349       {
51350         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51351       };
51352     } catch (...) {
51353       {
51354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51355       };
51356     }
51357   }
51358
51359 }
51360
51361
51362 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Reserve(void * jarg1, unsigned long jarg2) {
51363   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51364   Dali::Vector< int >::SizeType arg2 ;
51365
51366   arg1 = (Dali::Vector< int > *)jarg1;
51367   arg2 = (Dali::Vector< int >::SizeType)jarg2;
51368   {
51369     try {
51370       (arg1)->Reserve(arg2);
51371     } catch (std::out_of_range& e) {
51372       {
51373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51374       };
51375     } catch (std::exception& e) {
51376       {
51377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51378       };
51379     } catch (Dali::DaliException e) {
51380       {
51381         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51382       };
51383     } catch (...) {
51384       {
51385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51386       };
51387     }
51388   }
51389
51390 }
51391
51392
51393 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
51394   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51395   Dali::Vector< int >::SizeType arg2 ;
51396
51397   arg1 = (Dali::Vector< int > *)jarg1;
51398   arg2 = (Dali::Vector< int >::SizeType)jarg2;
51399   {
51400     try {
51401       (arg1)->Resize(arg2);
51402     } catch (std::out_of_range& e) {
51403       {
51404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51405       };
51406     } catch (std::exception& e) {
51407       {
51408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51409       };
51410     } catch (Dali::DaliException e) {
51411       {
51412         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51413       };
51414     } catch (...) {
51415       {
51416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51417       };
51418     }
51419   }
51420
51421 }
51422
51423
51424 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_1(void * jarg1, unsigned long jarg2, int jarg3) {
51425   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51426   Dali::Vector< int >::SizeType arg2 ;
51427   Dali::Vector< int >::ItemType *arg3 = 0 ;
51428   Dali::Vector< int >::ItemType temp3 ;
51429
51430   arg1 = (Dali::Vector< int > *)jarg1;
51431   arg2 = (Dali::Vector< int >::SizeType)jarg2;
51432   temp3 = (Dali::Vector< int >::ItemType)jarg3;
51433   arg3 = &temp3;
51434   {
51435     try {
51436       (arg1)->Resize(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
51437     } catch (std::out_of_range& e) {
51438       {
51439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51440       };
51441     } catch (std::exception& e) {
51442       {
51443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51444       };
51445     } catch (Dali::DaliException e) {
51446       {
51447         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51448       };
51449     } catch (...) {
51450       {
51451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51452       };
51453     }
51454   }
51455
51456 }
51457
51458
51459 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_0(void * jarg1, void * jarg2) {
51460   void * jresult ;
51461   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51462   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51463   Dali::Vector< int >::Iterator result;
51464
51465   arg1 = (Dali::Vector< int > *)jarg1;
51466   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51467   {
51468     try {
51469       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2);
51470     } catch (std::out_of_range& e) {
51471       {
51472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51473       };
51474     } catch (std::exception& e) {
51475       {
51476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51477       };
51478     } catch (Dali::DaliException e) {
51479       {
51480         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51481       };
51482     } catch (...) {
51483       {
51484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51485       };
51486     }
51487   }
51488
51489   jresult = (void *)result;
51490   return jresult;
51491 }
51492
51493
51494 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
51495   void * jresult ;
51496   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51497   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51498   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
51499   Dali::Vector< int >::Iterator result;
51500
51501   arg1 = (Dali::Vector< int > *)jarg1;
51502   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51503   arg3 = (Dali::Vector< int >::Iterator)jarg3;
51504   {
51505     try {
51506       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2,arg3);
51507     } catch (std::out_of_range& e) {
51508       {
51509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51510       };
51511     } catch (std::exception& e) {
51512       {
51513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51514       };
51515     } catch (Dali::DaliException e) {
51516       {
51517         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51518       };
51519     } catch (...) {
51520       {
51521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51522       };
51523     }
51524   }
51525
51526   jresult = (void *)result;
51527   return jresult;
51528 }
51529
51530
51531 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Remove(void * jarg1, void * jarg2) {
51532   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51533   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51534
51535   arg1 = (Dali::Vector< int > *)jarg1;
51536   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51537   {
51538     try {
51539       (arg1)->Remove(arg2);
51540     } catch (std::out_of_range& e) {
51541       {
51542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51543       };
51544     } catch (std::exception& e) {
51545       {
51546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51547       };
51548     } catch (Dali::DaliException e) {
51549       {
51550         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51551       };
51552     } catch (...) {
51553       {
51554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51555       };
51556     }
51557   }
51558
51559 }
51560
51561
51562 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Swap(void * jarg1, void * jarg2) {
51563   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51564   Dali::Vector< int > *arg2 = 0 ;
51565
51566   arg1 = (Dali::Vector< int > *)jarg1;
51567   arg2 = (Dali::Vector< int > *)jarg2;
51568   if (!arg2) {
51569     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > & type is null", 0);
51570     return ;
51571   }
51572   {
51573     try {
51574       (arg1)->Swap(*arg2);
51575     } catch (std::out_of_range& e) {
51576       {
51577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51578       };
51579     } catch (std::exception& e) {
51580       {
51581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51582       };
51583     } catch (Dali::DaliException e) {
51584       {
51585         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51586       };
51587     } catch (...) {
51588       {
51589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51590       };
51591     }
51592   }
51593
51594 }
51595
51596
51597 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Clear(void * jarg1) {
51598   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51599
51600   arg1 = (Dali::Vector< int > *)jarg1;
51601   {
51602     try {
51603       (arg1)->Clear();
51604     } catch (std::out_of_range& e) {
51605       {
51606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51607       };
51608     } catch (std::exception& e) {
51609       {
51610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51611       };
51612     } catch (Dali::DaliException e) {
51613       {
51614         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51615       };
51616     } catch (...) {
51617       {
51618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51619       };
51620     }
51621   }
51622
51623 }
51624
51625
51626 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Release(void * jarg1) {
51627   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51628
51629   arg1 = (Dali::Vector< int > *)jarg1;
51630   {
51631     try {
51632       (arg1)->Release();
51633     } catch (std::out_of_range& e) {
51634       {
51635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51636       };
51637     } catch (std::exception& e) {
51638       {
51639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51640       };
51641     } catch (Dali::DaliException e) {
51642       {
51643         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51644       };
51645     } catch (...) {
51646       {
51647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51648       };
51649     }
51650   }
51651
51652 }
51653
51654
51655 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorFloat_BaseType_get() {
51656   int jresult ;
51657   int result;
51658
51659   result = (int)Dali::Vector< float >::BaseType;
51660   jresult = (int)result;
51661   return jresult;
51662 }
51663
51664
51665 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_0() {
51666   void * jresult ;
51667   Dali::Vector< float > *result = 0 ;
51668
51669   {
51670     try {
51671       result = (Dali::Vector< float > *)new Dali::Vector< float >();
51672     } catch (std::out_of_range& e) {
51673       {
51674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51675       };
51676     } catch (std::exception& e) {
51677       {
51678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51679       };
51680     } catch (Dali::DaliException e) {
51681       {
51682         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51683       };
51684     } catch (...) {
51685       {
51686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51687       };
51688     }
51689   }
51690
51691   jresult = (void *)result;
51692   return jresult;
51693 }
51694
51695
51696 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorFloat(void * jarg1) {
51697   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51698
51699   arg1 = (Dali::Vector< float > *)jarg1;
51700   {
51701     try {
51702       delete arg1;
51703     } catch (std::out_of_range& e) {
51704       {
51705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51706       };
51707     } catch (std::exception& e) {
51708       {
51709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51710       };
51711     } catch (Dali::DaliException e) {
51712       {
51713         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51714       };
51715     } catch (...) {
51716       {
51717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51718       };
51719     }
51720   }
51721
51722 }
51723
51724
51725 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_1(void * jarg1) {
51726   void * jresult ;
51727   Dali::Vector< float > *arg1 = 0 ;
51728   Dali::Vector< float > *result = 0 ;
51729
51730   arg1 = (Dali::Vector< float > *)jarg1;
51731   if (!arg1) {
51732     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
51733     return 0;
51734   }
51735   {
51736     try {
51737       result = (Dali::Vector< float > *)new Dali::Vector< float >((Dali::Vector< float > const &)*arg1);
51738     } catch (std::out_of_range& e) {
51739       {
51740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51741       };
51742     } catch (std::exception& e) {
51743       {
51744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51745       };
51746     } catch (Dali::DaliException e) {
51747       {
51748         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51749       };
51750     } catch (...) {
51751       {
51752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51753       };
51754     }
51755   }
51756
51757   jresult = (void *)result;
51758   return jresult;
51759 }
51760
51761
51762 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Assign(void * jarg1, void * jarg2) {
51763   void * jresult ;
51764   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51765   Dali::Vector< float > *arg2 = 0 ;
51766   Dali::Vector< float > *result = 0 ;
51767
51768   arg1 = (Dali::Vector< float > *)jarg1;
51769   arg2 = (Dali::Vector< float > *)jarg2;
51770   if (!arg2) {
51771     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
51772     return 0;
51773   }
51774   {
51775     try {
51776       result = (Dali::Vector< float > *) &(arg1)->operator =((Dali::Vector< float > const &)*arg2);
51777     } catch (std::out_of_range& e) {
51778       {
51779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51780       };
51781     } catch (std::exception& e) {
51782       {
51783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51784       };
51785     } catch (Dali::DaliException e) {
51786       {
51787         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51788       };
51789     } catch (...) {
51790       {
51791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51792       };
51793     }
51794   }
51795
51796   jresult = (void *)result;
51797   return jresult;
51798 }
51799
51800
51801 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Begin(void * jarg1) {
51802   void * jresult ;
51803   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51804   Dali::Vector< float >::Iterator result;
51805
51806   arg1 = (Dali::Vector< float > *)jarg1;
51807   {
51808     try {
51809       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->Begin();
51810     } catch (std::out_of_range& e) {
51811       {
51812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51813       };
51814     } catch (std::exception& e) {
51815       {
51816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51817       };
51818     } catch (Dali::DaliException e) {
51819       {
51820         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51821       };
51822     } catch (...) {
51823       {
51824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51825       };
51826     }
51827   }
51828
51829   jresult = (void *)result;
51830   return jresult;
51831 }
51832
51833
51834 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_End(void * jarg1) {
51835   void * jresult ;
51836   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51837   Dali::Vector< float >::Iterator result;
51838
51839   arg1 = (Dali::Vector< float > *)jarg1;
51840   {
51841     try {
51842       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->End();
51843     } catch (std::out_of_range& e) {
51844       {
51845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51846       };
51847     } catch (std::exception& e) {
51848       {
51849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51850       };
51851     } catch (Dali::DaliException e) {
51852       {
51853         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51854       };
51855     } catch (...) {
51856       {
51857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51858       };
51859     }
51860   }
51861
51862   jresult = (void *)result;
51863   return jresult;
51864 }
51865
51866
51867 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
51868   void * jresult ;
51869   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51870   Dali::Vector< float >::SizeType arg2 ;
51871   Dali::Vector< float >::ItemType *result = 0 ;
51872
51873   arg1 = (Dali::Vector< float > *)jarg1;
51874   arg2 = (Dali::Vector< float >::SizeType)jarg2;
51875   {
51876     try {
51877       result = (Dali::Vector< float >::ItemType *) &(arg1)->operator [](arg2);
51878     } catch (std::out_of_range& e) {
51879       {
51880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51881       };
51882     } catch (std::exception& e) {
51883       {
51884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51885       };
51886     } catch (Dali::DaliException e) {
51887       {
51888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51889       };
51890     } catch (...) {
51891       {
51892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51893       };
51894     }
51895   }
51896
51897   jresult = (void *)result;
51898   return jresult;
51899 }
51900
51901
51902 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_PushBack(void * jarg1, float jarg2) {
51903   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51904   Dali::Vector< float >::ItemType *arg2 = 0 ;
51905   Dali::Vector< float >::ItemType temp2 ;
51906
51907   arg1 = (Dali::Vector< float > *)jarg1;
51908   temp2 = (Dali::Vector< float >::ItemType)jarg2;
51909   arg2 = &temp2;
51910   {
51911     try {
51912       (arg1)->PushBack((Dali::Vector< float >::ItemType const &)*arg2);
51913     } catch (std::out_of_range& e) {
51914       {
51915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51916       };
51917     } catch (std::exception& e) {
51918       {
51919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51920       };
51921     } catch (Dali::DaliException e) {
51922       {
51923         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51924       };
51925     } catch (...) {
51926       {
51927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51928       };
51929     }
51930   }
51931
51932 }
51933
51934
51935 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_0(void * jarg1, void * jarg2, float jarg3) {
51936   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51937   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
51938   Dali::Vector< float >::ItemType *arg3 = 0 ;
51939   Dali::Vector< float >::ItemType temp3 ;
51940
51941   arg1 = (Dali::Vector< float > *)jarg1;
51942   arg2 = (Dali::Vector< float >::Iterator)jarg2;
51943   temp3 = (Dali::Vector< float >::ItemType)jarg3;
51944   arg3 = &temp3;
51945   {
51946     try {
51947       (arg1)->Insert(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
51948     } catch (std::out_of_range& e) {
51949       {
51950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51951       };
51952     } catch (std::exception& e) {
51953       {
51954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51955       };
51956     } catch (Dali::DaliException e) {
51957       {
51958         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51959       };
51960     } catch (...) {
51961       {
51962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51963       };
51964     }
51965   }
51966
51967 }
51968
51969
51970 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
51971   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51972   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
51973   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
51974   Dali::Vector< float >::Iterator arg4 = (Dali::Vector< float >::Iterator) 0 ;
51975
51976   arg1 = (Dali::Vector< float > *)jarg1;
51977   arg2 = (Dali::Vector< float >::Iterator)jarg2;
51978   arg3 = (Dali::Vector< float >::Iterator)jarg3;
51979   arg4 = (Dali::Vector< float >::Iterator)jarg4;
51980   {
51981     try {
51982       (arg1)->Insert(arg2,arg3,arg4);
51983     } catch (std::out_of_range& e) {
51984       {
51985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51986       };
51987     } catch (std::exception& e) {
51988       {
51989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51990       };
51991     } catch (Dali::DaliException e) {
51992       {
51993         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51994       };
51995     } catch (...) {
51996       {
51997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51998       };
51999     }
52000   }
52001
52002 }
52003
52004
52005 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Reserve(void * jarg1, unsigned long jarg2) {
52006   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52007   Dali::Vector< float >::SizeType arg2 ;
52008
52009   arg1 = (Dali::Vector< float > *)jarg1;
52010   arg2 = (Dali::Vector< float >::SizeType)jarg2;
52011   {
52012     try {
52013       (arg1)->Reserve(arg2);
52014     } catch (std::out_of_range& e) {
52015       {
52016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52017       };
52018     } catch (std::exception& e) {
52019       {
52020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52021       };
52022     } catch (Dali::DaliException e) {
52023       {
52024         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52025       };
52026     } catch (...) {
52027       {
52028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52029       };
52030     }
52031   }
52032
52033 }
52034
52035 //// ========================= end of part 2 =============================
52036
52037 //// ========================== start part 3 ===============================
52038
52039
52040 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
52041   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52042   Dali::Vector< float >::SizeType arg2 ;
52043
52044   arg1 = (Dali::Vector< float > *)jarg1;
52045   arg2 = (Dali::Vector< float >::SizeType)jarg2;
52046   {
52047     try {
52048       (arg1)->Resize(arg2);
52049     } catch (std::out_of_range& e) {
52050       {
52051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52052       };
52053     } catch (std::exception& e) {
52054       {
52055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52056       };
52057     } catch (Dali::DaliException e) {
52058       {
52059         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52060       };
52061     } catch (...) {
52062       {
52063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52064       };
52065     }
52066   }
52067
52068 }
52069
52070
52071 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_1(void * jarg1, unsigned long jarg2, float jarg3) {
52072   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52073   Dali::Vector< float >::SizeType arg2 ;
52074   Dali::Vector< float >::ItemType *arg3 = 0 ;
52075   Dali::Vector< float >::ItemType temp3 ;
52076
52077   arg1 = (Dali::Vector< float > *)jarg1;
52078   arg2 = (Dali::Vector< float >::SizeType)jarg2;
52079   temp3 = (Dali::Vector< float >::ItemType)jarg3;
52080   arg3 = &temp3;
52081   {
52082     try {
52083       (arg1)->Resize(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
52084     } catch (std::out_of_range& e) {
52085       {
52086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52087       };
52088     } catch (std::exception& e) {
52089       {
52090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52091       };
52092     } catch (Dali::DaliException e) {
52093       {
52094         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52095       };
52096     } catch (...) {
52097       {
52098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52099       };
52100     }
52101   }
52102
52103 }
52104
52105
52106 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_0(void * jarg1, void * jarg2) {
52107   void * jresult ;
52108   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52109   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
52110   Dali::Vector< float >::Iterator result;
52111
52112   arg1 = (Dali::Vector< float > *)jarg1;
52113   arg2 = (Dali::Vector< float >::Iterator)jarg2;
52114   {
52115     try {
52116       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2);
52117     } catch (std::out_of_range& e) {
52118       {
52119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52120       };
52121     } catch (std::exception& e) {
52122       {
52123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52124       };
52125     } catch (Dali::DaliException e) {
52126       {
52127         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52128       };
52129     } catch (...) {
52130       {
52131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52132       };
52133     }
52134   }
52135
52136   jresult = (void *)result;
52137   return jresult;
52138 }
52139
52140
52141 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
52142   void * jresult ;
52143   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52144   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
52145   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
52146   Dali::Vector< float >::Iterator result;
52147
52148   arg1 = (Dali::Vector< float > *)jarg1;
52149   arg2 = (Dali::Vector< float >::Iterator)jarg2;
52150   arg3 = (Dali::Vector< float >::Iterator)jarg3;
52151   {
52152     try {
52153       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2,arg3);
52154     } catch (std::out_of_range& e) {
52155       {
52156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52157       };
52158     } catch (std::exception& e) {
52159       {
52160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52161       };
52162     } catch (Dali::DaliException e) {
52163       {
52164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52165       };
52166     } catch (...) {
52167       {
52168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52169       };
52170     }
52171   }
52172
52173   jresult = (void *)result;
52174   return jresult;
52175 }
52176
52177
52178 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Remove(void * jarg1, void * jarg2) {
52179   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52180   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
52181
52182   arg1 = (Dali::Vector< float > *)jarg1;
52183   arg2 = (Dali::Vector< float >::Iterator)jarg2;
52184   {
52185     try {
52186       (arg1)->Remove(arg2);
52187     } catch (std::out_of_range& e) {
52188       {
52189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52190       };
52191     } catch (std::exception& e) {
52192       {
52193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52194       };
52195     } catch (Dali::DaliException e) {
52196       {
52197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52198       };
52199     } catch (...) {
52200       {
52201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52202       };
52203     }
52204   }
52205
52206 }
52207
52208
52209 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Swap(void * jarg1, void * jarg2) {
52210   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52211   Dali::Vector< float > *arg2 = 0 ;
52212
52213   arg1 = (Dali::Vector< float > *)jarg1;
52214   arg2 = (Dali::Vector< float > *)jarg2;
52215   if (!arg2) {
52216     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > & type is null", 0);
52217     return ;
52218   }
52219   {
52220     try {
52221       (arg1)->Swap(*arg2);
52222     } catch (std::out_of_range& e) {
52223       {
52224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52225       };
52226     } catch (std::exception& e) {
52227       {
52228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52229       };
52230     } catch (Dali::DaliException e) {
52231       {
52232         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52233       };
52234     } catch (...) {
52235       {
52236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52237       };
52238     }
52239   }
52240
52241 }
52242
52243
52244 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Clear(void * jarg1) {
52245   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52246
52247   arg1 = (Dali::Vector< float > *)jarg1;
52248   {
52249     try {
52250       (arg1)->Clear();
52251     } catch (std::out_of_range& e) {
52252       {
52253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52254       };
52255     } catch (std::exception& e) {
52256       {
52257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52258       };
52259     } catch (Dali::DaliException e) {
52260       {
52261         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52262       };
52263     } catch (...) {
52264       {
52265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52266       };
52267     }
52268   }
52269
52270 }
52271
52272
52273 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Release(void * jarg1) {
52274   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52275
52276   arg1 = (Dali::Vector< float > *)jarg1;
52277   {
52278     try {
52279       (arg1)->Release();
52280     } catch (std::out_of_range& e) {
52281       {
52282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52283       };
52284     } catch (std::exception& e) {
52285       {
52286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52287       };
52288     } catch (Dali::DaliException e) {
52289       {
52290         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52291       };
52292     } catch (...) {
52293       {
52294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52295       };
52296     }
52297   }
52298
52299 }
52300
52301
52302 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_BaseType_get() {
52303   int jresult ;
52304   int result;
52305
52306   result = (int)Dali::Vector< unsigned char >::BaseType;
52307   jresult = (int)result;
52308   return jresult;
52309 }
52310
52311
52312 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_0() {
52313   void * jresult ;
52314   Dali::Vector< unsigned char > *result = 0 ;
52315
52316   {
52317     try {
52318       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >();
52319     } catch (std::out_of_range& e) {
52320       {
52321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52322       };
52323     } catch (std::exception& e) {
52324       {
52325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52326       };
52327     } catch (Dali::DaliException e) {
52328       {
52329         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52330       };
52331     } catch (...) {
52332       {
52333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52334       };
52335     }
52336   }
52337
52338   jresult = (void *)result;
52339   return jresult;
52340 }
52341
52342
52343 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUnsignedChar(void * jarg1) {
52344   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52345
52346   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52347   {
52348     try {
52349       delete arg1;
52350     } catch (std::out_of_range& e) {
52351       {
52352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52353       };
52354     } catch (std::exception& e) {
52355       {
52356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52357       };
52358     } catch (Dali::DaliException e) {
52359       {
52360         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52361       };
52362     } catch (...) {
52363       {
52364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52365       };
52366     }
52367   }
52368
52369 }
52370
52371
52372 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_1(void * jarg1) {
52373   void * jresult ;
52374   Dali::Vector< unsigned char > *arg1 = 0 ;
52375   Dali::Vector< unsigned char > *result = 0 ;
52376
52377   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52378   if (!arg1) {
52379     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
52380     return 0;
52381   }
52382   {
52383     try {
52384       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >((Dali::Vector< unsigned char > const &)*arg1);
52385     } catch (std::out_of_range& e) {
52386       {
52387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52388       };
52389     } catch (std::exception& e) {
52390       {
52391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52392       };
52393     } catch (Dali::DaliException e) {
52394       {
52395         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52396       };
52397     } catch (...) {
52398       {
52399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52400       };
52401     }
52402   }
52403
52404   jresult = (void *)result;
52405   return jresult;
52406 }
52407
52408
52409 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Assign(void * jarg1, void * jarg2) {
52410   void * jresult ;
52411   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52412   Dali::Vector< unsigned char > *arg2 = 0 ;
52413   Dali::Vector< unsigned char > *result = 0 ;
52414
52415   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52416   arg2 = (Dali::Vector< unsigned char > *)jarg2;
52417   if (!arg2) {
52418     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
52419     return 0;
52420   }
52421   {
52422     try {
52423       result = (Dali::Vector< unsigned char > *) &(arg1)->operator =((Dali::Vector< unsigned char > const &)*arg2);
52424     } catch (std::out_of_range& e) {
52425       {
52426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52427       };
52428     } catch (std::exception& e) {
52429       {
52430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52431       };
52432     } catch (Dali::DaliException e) {
52433       {
52434         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52435       };
52436     } catch (...) {
52437       {
52438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52439       };
52440     }
52441   }
52442
52443   jresult = (void *)result;
52444   return jresult;
52445 }
52446
52447
52448 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Begin(void * jarg1) {
52449   void * jresult ;
52450   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52451   Dali::Vector< unsigned char >::Iterator result;
52452
52453   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52454   {
52455     try {
52456       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->Begin();
52457     } catch (std::out_of_range& e) {
52458       {
52459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52460       };
52461     } catch (std::exception& e) {
52462       {
52463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52464       };
52465     } catch (Dali::DaliException e) {
52466       {
52467         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52468       };
52469     } catch (...) {
52470       {
52471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52472       };
52473     }
52474   }
52475
52476   jresult = (void *)result;
52477   return jresult;
52478 }
52479
52480
52481 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_End(void * jarg1) {
52482   void * jresult ;
52483   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52484   Dali::Vector< unsigned char >::Iterator result;
52485
52486   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52487   {
52488     try {
52489       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->End();
52490     } catch (std::out_of_range& e) {
52491       {
52492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52493       };
52494     } catch (std::exception& e) {
52495       {
52496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52497       };
52498     } catch (Dali::DaliException e) {
52499       {
52500         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52501       };
52502     } catch (...) {
52503       {
52504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52505       };
52506     }
52507   }
52508
52509   jresult = (void *)result;
52510   return jresult;
52511 }
52512
52513
52514 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
52515   void * jresult ;
52516   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52517   Dali::Vector< unsigned char >::SizeType arg2 ;
52518   Dali::Vector< unsigned char >::ItemType *result = 0 ;
52519
52520   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52521   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
52522   {
52523     try {
52524       result = (Dali::Vector< unsigned char >::ItemType *) &(arg1)->operator [](arg2);
52525     } catch (std::out_of_range& e) {
52526       {
52527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52528       };
52529     } catch (std::exception& e) {
52530       {
52531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52532       };
52533     } catch (Dali::DaliException e) {
52534       {
52535         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52536       };
52537     } catch (...) {
52538       {
52539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52540       };
52541     }
52542   }
52543
52544   jresult = (void *)result;
52545   return jresult;
52546 }
52547
52548
52549 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_PushBack(void * jarg1, unsigned char jarg2) {
52550   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52551   Dali::Vector< unsigned char >::ItemType *arg2 = 0 ;
52552   Dali::Vector< unsigned char >::ItemType temp2 ;
52553
52554   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52555   temp2 = (Dali::Vector< unsigned char >::ItemType)jarg2;
52556   arg2 = &temp2;
52557   {
52558     try {
52559       (arg1)->PushBack((Dali::Vector< unsigned char >::ItemType const &)*arg2);
52560     } catch (std::out_of_range& e) {
52561       {
52562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52563       };
52564     } catch (std::exception& e) {
52565       {
52566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52567       };
52568     } catch (Dali::DaliException e) {
52569       {
52570         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52571       };
52572     } catch (...) {
52573       {
52574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52575       };
52576     }
52577   }
52578
52579 }
52580
52581
52582 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_0(void * jarg1, unsigned char* jarg2, unsigned char jarg3) {
52583   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52584   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52585   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
52586   Dali::Vector< unsigned char >::ItemType temp3 ;
52587
52588   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52589   arg2 = jarg2;
52590   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
52591   arg3 = &temp3;
52592   {
52593     try {
52594       (arg1)->Insert(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
52595     } catch (std::out_of_range& e) {
52596       {
52597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52598       };
52599     } catch (std::exception& e) {
52600       {
52601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52602       };
52603     } catch (Dali::DaliException e) {
52604       {
52605         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52606       };
52607     } catch (...) {
52608       {
52609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52610       };
52611     }
52612   }
52613
52614
52615
52616 }
52617
52618
52619 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3, void * jarg4) {
52620   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52621   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52622   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52623   Dali::Vector< unsigned char >::Iterator arg4 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52624
52625   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52626   arg2 = jarg2;
52627   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
52628   arg4 = (Dali::Vector< unsigned char >::Iterator)jarg4;
52629   {
52630     try {
52631       (arg1)->Insert(arg2,arg3,arg4);
52632     } catch (std::out_of_range& e) {
52633       {
52634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52635       };
52636     } catch (std::exception& e) {
52637       {
52638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52639       };
52640     } catch (Dali::DaliException e) {
52641       {
52642         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52643       };
52644     } catch (...) {
52645       {
52646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52647       };
52648     }
52649   }
52650
52651
52652
52653 }
52654
52655
52656 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Reserve(void * jarg1, unsigned long jarg2) {
52657   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52658   Dali::Vector< unsigned char >::SizeType arg2 ;
52659
52660   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52661   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
52662   {
52663     try {
52664       (arg1)->Reserve(arg2);
52665     } catch (std::out_of_range& e) {
52666       {
52667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52668       };
52669     } catch (std::exception& e) {
52670       {
52671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52672       };
52673     } catch (Dali::DaliException e) {
52674       {
52675         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52676       };
52677     } catch (...) {
52678       {
52679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52680       };
52681     }
52682   }
52683
52684 }
52685
52686
52687 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
52688   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52689   Dali::Vector< unsigned char >::SizeType arg2 ;
52690
52691   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52692   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
52693   {
52694     try {
52695       (arg1)->Resize(arg2);
52696     } catch (std::out_of_range& e) {
52697       {
52698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52699       };
52700     } catch (std::exception& e) {
52701       {
52702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52703       };
52704     } catch (Dali::DaliException e) {
52705       {
52706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52707       };
52708     } catch (...) {
52709       {
52710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52711       };
52712     }
52713   }
52714
52715 }
52716
52717
52718 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_1(void * jarg1, unsigned long jarg2, unsigned char jarg3) {
52719   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52720   Dali::Vector< unsigned char >::SizeType arg2 ;
52721   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
52722   Dali::Vector< unsigned char >::ItemType temp3 ;
52723
52724   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52725   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
52726   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
52727   arg3 = &temp3;
52728   {
52729     try {
52730       (arg1)->Resize(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
52731     } catch (std::out_of_range& e) {
52732       {
52733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52734       };
52735     } catch (std::exception& e) {
52736       {
52737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52738       };
52739     } catch (Dali::DaliException e) {
52740       {
52741         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52742       };
52743     } catch (...) {
52744       {
52745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52746       };
52747     }
52748   }
52749
52750 }
52751
52752
52753 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_0(void * jarg1, unsigned char* jarg2) {
52754   void * jresult ;
52755   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52756   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52757   Dali::Vector< unsigned char >::Iterator result;
52758
52759   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52760   arg2 = jarg2;
52761   {
52762     try {
52763       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2);
52764     } catch (std::out_of_range& e) {
52765       {
52766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52767       };
52768     } catch (std::exception& e) {
52769       {
52770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52771       };
52772     } catch (Dali::DaliException e) {
52773       {
52774         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52775       };
52776     } catch (...) {
52777       {
52778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52779       };
52780     }
52781   }
52782
52783   jresult = (void *)result;
52784
52785
52786   return jresult;
52787 }
52788
52789
52790 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3) {
52791   void * jresult ;
52792   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52793   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52794   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52795   Dali::Vector< unsigned char >::Iterator result;
52796
52797   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52798   arg2 = jarg2;
52799   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
52800   {
52801     try {
52802       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2,arg3);
52803     } catch (std::out_of_range& e) {
52804       {
52805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52806       };
52807     } catch (std::exception& e) {
52808       {
52809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52810       };
52811     } catch (Dali::DaliException e) {
52812       {
52813         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52814       };
52815     } catch (...) {
52816       {
52817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52818       };
52819     }
52820   }
52821
52822   jresult = (void *)result;
52823
52824
52825   return jresult;
52826 }
52827
52828
52829 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Remove(void * jarg1, unsigned char* jarg2) {
52830   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52831   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52832
52833   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52834   arg2 = jarg2;
52835   {
52836     try {
52837       (arg1)->Remove(arg2);
52838     } catch (std::out_of_range& e) {
52839       {
52840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52841       };
52842     } catch (std::exception& e) {
52843       {
52844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52845       };
52846     } catch (Dali::DaliException e) {
52847       {
52848         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52849       };
52850     } catch (...) {
52851       {
52852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52853       };
52854     }
52855   }
52856
52857
52858
52859 }
52860
52861
52862 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Swap(void * jarg1, void * jarg2) {
52863   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52864   Dali::Vector< unsigned char > *arg2 = 0 ;
52865
52866   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52867   arg2 = (Dali::Vector< unsigned char > *)jarg2;
52868   if (!arg2) {
52869     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > & type is null", 0);
52870     return ;
52871   }
52872   {
52873     try {
52874       (arg1)->Swap(*arg2);
52875     } catch (std::out_of_range& e) {
52876       {
52877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52878       };
52879     } catch (std::exception& e) {
52880       {
52881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52882       };
52883     } catch (Dali::DaliException e) {
52884       {
52885         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52886       };
52887     } catch (...) {
52888       {
52889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52890       };
52891     }
52892   }
52893
52894 }
52895
52896
52897 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Clear(void * jarg1) {
52898   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52899
52900   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52901   {
52902     try {
52903       (arg1)->Clear();
52904     } catch (std::out_of_range& e) {
52905       {
52906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52907       };
52908     } catch (std::exception& e) {
52909       {
52910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52911       };
52912     } catch (Dali::DaliException e) {
52913       {
52914         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52915       };
52916     } catch (...) {
52917       {
52918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52919       };
52920     }
52921   }
52922
52923 }
52924
52925
52926 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Release(void * jarg1) {
52927   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52928
52929   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52930   {
52931     try {
52932       (arg1)->Release();
52933     } catch (std::out_of_range& e) {
52934       {
52935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52936       };
52937     } catch (std::exception& e) {
52938       {
52939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52940       };
52941     } catch (Dali::DaliException e) {
52942       {
52943         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52944       };
52945     } catch (...) {
52946       {
52947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52948       };
52949     }
52950   }
52951
52952 }
52953
52954
52955 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUint16Pair_BaseType_get() {
52956   int jresult ;
52957   int result;
52958
52959   result = (int)Dali::Vector< Dali::Uint16Pair >::BaseType;
52960   jresult = (int)result;
52961   return jresult;
52962 }
52963
52964
52965 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_0() {
52966   void * jresult ;
52967   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
52968
52969   {
52970     try {
52971       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >();
52972     } catch (std::out_of_range& e) {
52973       {
52974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52975       };
52976     } catch (std::exception& e) {
52977       {
52978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52979       };
52980     } catch (Dali::DaliException e) {
52981       {
52982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52983       };
52984     } catch (...) {
52985       {
52986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52987       };
52988     }
52989   }
52990
52991   jresult = (void *)result;
52992   return jresult;
52993 }
52994
52995
52996 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUint16Pair(void * jarg1) {
52997   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
52998
52999   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53000   {
53001     try {
53002       delete arg1;
53003     } catch (std::out_of_range& e) {
53004       {
53005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53006       };
53007     } catch (std::exception& e) {
53008       {
53009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53010       };
53011     } catch (Dali::DaliException e) {
53012       {
53013         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53014       };
53015     } catch (...) {
53016       {
53017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53018       };
53019     }
53020   }
53021
53022 }
53023
53024
53025 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_1(void * jarg1) {
53026   void * jresult ;
53027   Dali::Vector< Dali::Uint16Pair > *arg1 = 0 ;
53028   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
53029
53030   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53031   if (!arg1) {
53032     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
53033     return 0;
53034   }
53035   {
53036     try {
53037       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >((Dali::Vector< Dali::Uint16Pair > const &)*arg1);
53038     } catch (std::out_of_range& e) {
53039       {
53040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53041       };
53042     } catch (std::exception& e) {
53043       {
53044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53045       };
53046     } catch (Dali::DaliException e) {
53047       {
53048         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53049       };
53050     } catch (...) {
53051       {
53052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53053       };
53054     }
53055   }
53056
53057   jresult = (void *)result;
53058   return jresult;
53059 }
53060
53061
53062 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Assign(void * jarg1, void * jarg2) {
53063   void * jresult ;
53064   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53065   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
53066   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
53067
53068   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53069   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
53070   if (!arg2) {
53071     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
53072     return 0;
53073   }
53074   {
53075     try {
53076       result = (Dali::Vector< Dali::Uint16Pair > *) &(arg1)->operator =((Dali::Vector< Dali::Uint16Pair > const &)*arg2);
53077     } catch (std::out_of_range& e) {
53078       {
53079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53080       };
53081     } catch (std::exception& e) {
53082       {
53083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53084       };
53085     } catch (Dali::DaliException e) {
53086       {
53087         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53088       };
53089     } catch (...) {
53090       {
53091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53092       };
53093     }
53094   }
53095
53096   jresult = (void *)result;
53097   return jresult;
53098 }
53099
53100
53101 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Begin(void * jarg1) {
53102   void * jresult ;
53103   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53104   Dali::Vector< Dali::Uint16Pair >::Iterator result;
53105
53106   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53107   {
53108     try {
53109       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->Begin();
53110     } catch (std::out_of_range& e) {
53111       {
53112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53113       };
53114     } catch (std::exception& e) {
53115       {
53116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53117       };
53118     } catch (Dali::DaliException e) {
53119       {
53120         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53121       };
53122     } catch (...) {
53123       {
53124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53125       };
53126     }
53127   }
53128
53129   jresult = (void *)result;
53130   return jresult;
53131 }
53132
53133
53134 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_End(void * jarg1) {
53135   void * jresult ;
53136   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53137   Dali::Vector< Dali::Uint16Pair >::Iterator result;
53138
53139   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53140   {
53141     try {
53142       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->End();
53143     } catch (std::out_of_range& e) {
53144       {
53145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53146       };
53147     } catch (std::exception& e) {
53148       {
53149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53150       };
53151     } catch (Dali::DaliException e) {
53152       {
53153         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53154       };
53155     } catch (...) {
53156       {
53157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53158       };
53159     }
53160   }
53161
53162   jresult = (void *)result;
53163   return jresult;
53164 }
53165
53166
53167 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
53168   void * jresult ;
53169   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53170   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
53171   Dali::Vector< Dali::Uint16Pair >::ItemType *result = 0 ;
53172
53173   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53174   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
53175   {
53176     try {
53177       result = (Dali::Vector< Dali::Uint16Pair >::ItemType *) &(arg1)->operator [](arg2);
53178     } catch (std::out_of_range& e) {
53179       {
53180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53181       };
53182     } catch (std::exception& e) {
53183       {
53184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53185       };
53186     } catch (Dali::DaliException e) {
53187       {
53188         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53189       };
53190     } catch (...) {
53191       {
53192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53193       };
53194     }
53195   }
53196
53197   jresult = (void *)result;
53198   return jresult;
53199 }
53200
53201
53202 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_PushBack(void * jarg1, void * jarg2) {
53203   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53204   Dali::Vector< Dali::Uint16Pair >::ItemType *arg2 = 0 ;
53205
53206   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53207   arg2 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg2;
53208   if (!arg2) {
53209     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
53210     return ;
53211   }
53212   {
53213     try {
53214       (arg1)->PushBack((Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg2);
53215     } catch (std::out_of_range& e) {
53216       {
53217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53218       };
53219     } catch (std::exception& e) {
53220       {
53221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53222       };
53223     } catch (Dali::DaliException e) {
53224       {
53225         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53226       };
53227     } catch (...) {
53228       {
53229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53230       };
53231     }
53232   }
53233
53234 }
53235
53236
53237 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
53238   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53239   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53240   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
53241
53242   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53243   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53244   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
53245   if (!arg3) {
53246     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
53247     return ;
53248   }
53249   {
53250     try {
53251       (arg1)->Insert(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
53252     } catch (std::out_of_range& e) {
53253       {
53254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53255       };
53256     } catch (std::exception& e) {
53257       {
53258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53259       };
53260     } catch (Dali::DaliException e) {
53261       {
53262         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53263       };
53264     } catch (...) {
53265       {
53266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53267       };
53268     }
53269   }
53270
53271 }
53272
53273
53274 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
53275   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53276   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53277   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53278   Dali::Vector< Dali::Uint16Pair >::Iterator arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53279
53280   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53281   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53282   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
53283   arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg4;
53284   {
53285     try {
53286       (arg1)->Insert(arg2,arg3,arg4);
53287     } catch (std::out_of_range& e) {
53288       {
53289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53290       };
53291     } catch (std::exception& e) {
53292       {
53293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53294       };
53295     } catch (Dali::DaliException e) {
53296       {
53297         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53298       };
53299     } catch (...) {
53300       {
53301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53302       };
53303     }
53304   }
53305
53306 }
53307
53308
53309 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Reserve(void * jarg1, unsigned long jarg2) {
53310   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53311   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
53312
53313   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53314   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
53315   {
53316     try {
53317       (arg1)->Reserve(arg2);
53318     } catch (std::out_of_range& e) {
53319       {
53320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53321       };
53322     } catch (std::exception& e) {
53323       {
53324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53325       };
53326     } catch (Dali::DaliException e) {
53327       {
53328         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53329       };
53330     } catch (...) {
53331       {
53332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53333       };
53334     }
53335   }
53336
53337 }
53338
53339
53340 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
53341   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53342   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
53343
53344   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53345   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
53346   {
53347     try {
53348       (arg1)->Resize(arg2);
53349     } catch (std::out_of_range& e) {
53350       {
53351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53352       };
53353     } catch (std::exception& e) {
53354       {
53355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53356       };
53357     } catch (Dali::DaliException e) {
53358       {
53359         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53360       };
53361     } catch (...) {
53362       {
53363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53364       };
53365     }
53366   }
53367
53368 }
53369
53370
53371 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3) {
53372   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53373   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
53374   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
53375
53376   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53377   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
53378   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
53379   if (!arg3) {
53380     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
53381     return ;
53382   }
53383   {
53384     try {
53385       (arg1)->Resize(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
53386     } catch (std::out_of_range& e) {
53387       {
53388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53389       };
53390     } catch (std::exception& e) {
53391       {
53392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53393       };
53394     } catch (Dali::DaliException e) {
53395       {
53396         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53397       };
53398     } catch (...) {
53399       {
53400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53401       };
53402     }
53403   }
53404
53405 }
53406
53407
53408 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_0(void * jarg1, void * jarg2) {
53409   void * jresult ;
53410   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53411   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53412   Dali::Vector< Dali::Uint16Pair >::Iterator result;
53413
53414   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53415   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53416   {
53417     try {
53418       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2);
53419     } catch (std::out_of_range& e) {
53420       {
53421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53422       };
53423     } catch (std::exception& e) {
53424       {
53425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53426       };
53427     } catch (Dali::DaliException e) {
53428       {
53429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53430       };
53431     } catch (...) {
53432       {
53433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53434       };
53435     }
53436   }
53437
53438   jresult = (void *)result;
53439   return jresult;
53440 }
53441
53442
53443 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
53444   void * jresult ;
53445   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53446   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53447   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53448   Dali::Vector< Dali::Uint16Pair >::Iterator result;
53449
53450   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53451   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53452   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
53453   {
53454     try {
53455       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2,arg3);
53456     } catch (std::out_of_range& e) {
53457       {
53458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53459       };
53460     } catch (std::exception& e) {
53461       {
53462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53463       };
53464     } catch (Dali::DaliException e) {
53465       {
53466         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53467       };
53468     } catch (...) {
53469       {
53470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53471       };
53472     }
53473   }
53474
53475   jresult = (void *)result;
53476   return jresult;
53477 }
53478
53479
53480 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Remove(void * jarg1, void * jarg2) {
53481   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53482   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53483
53484   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53485   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53486   {
53487     try {
53488       (arg1)->Remove(arg2);
53489     } catch (std::out_of_range& e) {
53490       {
53491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53492       };
53493     } catch (std::exception& e) {
53494       {
53495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53496       };
53497     } catch (Dali::DaliException e) {
53498       {
53499         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53500       };
53501     } catch (...) {
53502       {
53503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53504       };
53505     }
53506   }
53507
53508 }
53509
53510
53511 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Swap(void * jarg1, void * jarg2) {
53512   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53513   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
53514
53515   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53516   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
53517   if (!arg2) {
53518     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > & type is null", 0);
53519     return ;
53520   }
53521   {
53522     try {
53523       (arg1)->Swap(*arg2);
53524     } catch (std::out_of_range& e) {
53525       {
53526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53527       };
53528     } catch (std::exception& e) {
53529       {
53530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53531       };
53532     } catch (Dali::DaliException e) {
53533       {
53534         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53535       };
53536     } catch (...) {
53537       {
53538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53539       };
53540     }
53541   }
53542
53543 }
53544
53545
53546 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Clear(void * jarg1) {
53547   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53548
53549   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53550   {
53551     try {
53552       (arg1)->Clear();
53553     } catch (std::out_of_range& e) {
53554       {
53555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53556       };
53557     } catch (std::exception& e) {
53558       {
53559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53560       };
53561     } catch (Dali::DaliException e) {
53562       {
53563         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53564       };
53565     } catch (...) {
53566       {
53567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53568       };
53569     }
53570   }
53571
53572 }
53573
53574
53575 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Release(void * jarg1) {
53576   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53577
53578   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53579   {
53580     try {
53581       (arg1)->Release();
53582     } catch (std::out_of_range& e) {
53583       {
53584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53585       };
53586     } catch (std::exception& e) {
53587       {
53588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53589       };
53590     } catch (Dali::DaliException e) {
53591       {
53592         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53593       };
53594     } catch (...) {
53595       {
53596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53597       };
53598     }
53599   }
53600
53601 }
53602
53603
53604 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VoidSignal() {
53605   void * jresult ;
53606   Dali::Signal< void () > *result = 0 ;
53607
53608   {
53609     try {
53610       result = (Dali::Signal< void () > *)new Dali::Signal< void () >();
53611     } catch (std::out_of_range& e) {
53612       {
53613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53614       };
53615     } catch (std::exception& e) {
53616       {
53617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53618       };
53619     } catch (Dali::DaliException e) {
53620       {
53621         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53622       };
53623     } catch (...) {
53624       {
53625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53626       };
53627     }
53628   }
53629
53630   jresult = (void *)result;
53631   return jresult;
53632 }
53633
53634
53635 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VoidSignal(void * jarg1) {
53636   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53637
53638   arg1 = (Dali::Signal< void () > *)jarg1;
53639   {
53640     try {
53641       delete arg1;
53642     } catch (std::out_of_range& e) {
53643       {
53644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53645       };
53646     } catch (std::exception& e) {
53647       {
53648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53649       };
53650     } catch (Dali::DaliException e) {
53651       {
53652         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53653       };
53654     } catch (...) {
53655       {
53656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53657       };
53658     }
53659   }
53660
53661 }
53662
53663
53664 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VoidSignal_Empty(void * jarg1) {
53665   unsigned int jresult ;
53666   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53667   bool result;
53668
53669   arg1 = (Dali::Signal< void () > *)jarg1;
53670   {
53671     try {
53672       result = (bool)((Dali::Signal< void () > const *)arg1)->Empty();
53673     } catch (std::out_of_range& e) {
53674       {
53675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53676       };
53677     } catch (std::exception& e) {
53678       {
53679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53680       };
53681     } catch (Dali::DaliException e) {
53682       {
53683         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53684       };
53685     } catch (...) {
53686       {
53687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53688       };
53689     }
53690   }
53691
53692   jresult = result;
53693   return jresult;
53694 }
53695
53696
53697 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VoidSignal_GetConnectionCount(void * jarg1) {
53698   unsigned long jresult ;
53699   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53700   std::size_t result;
53701
53702   arg1 = (Dali::Signal< void () > *)jarg1;
53703   {
53704     try {
53705       result = ((Dali::Signal< void () > const *)arg1)->GetConnectionCount();
53706     } catch (std::out_of_range& e) {
53707       {
53708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53709       };
53710     } catch (std::exception& e) {
53711       {
53712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53713       };
53714     } catch (Dali::DaliException e) {
53715       {
53716         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53717       };
53718     } catch (...) {
53719       {
53720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53721       };
53722     }
53723   }
53724
53725   jresult = (unsigned long)result;
53726   return jresult;
53727 }
53728
53729
53730 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_0(void * jarg1, void * jarg2) {
53731   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53732   void (*arg2)() = (void (*)()) 0 ;
53733
53734   arg1 = (Dali::Signal< void () > *)jarg1;
53735   arg2 = (void (*)())jarg2;
53736   {
53737     try {
53738       (arg1)->Connect(arg2);
53739     } catch (std::out_of_range& e) {
53740       {
53741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53742       };
53743     } catch (std::exception& e) {
53744       {
53745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53746       };
53747     } catch (Dali::DaliException e) {
53748       {
53749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53750       };
53751     } catch (...) {
53752       {
53753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53754       };
53755     }
53756   }
53757
53758 }
53759
53760
53761 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Disconnect(void * jarg1, void * jarg2) {
53762   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53763   void (*arg2)() = (void (*)()) 0 ;
53764
53765   arg1 = (Dali::Signal< void () > *)jarg1;
53766   arg2 = (void (*)())jarg2;
53767   {
53768     try {
53769       (arg1)->Disconnect(arg2);
53770     } catch (std::out_of_range& e) {
53771       {
53772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53773       };
53774     } catch (std::exception& e) {
53775       {
53776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53777       };
53778     } catch (Dali::DaliException e) {
53779       {
53780         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53781       };
53782     } catch (...) {
53783       {
53784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53785       };
53786     }
53787   }
53788
53789 }
53790
53791
53792 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
53793   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53794   Dali::ConnectionTrackerInterface *arg2 = (Dali::ConnectionTrackerInterface *) 0 ;
53795   Dali::FunctorDelegate *arg3 = (Dali::FunctorDelegate *) 0 ;
53796
53797   arg1 = (Dali::Signal< void () > *)jarg1;
53798   arg2 = (Dali::ConnectionTrackerInterface *)jarg2;
53799   arg3 = (Dali::FunctorDelegate *)jarg3;
53800   {
53801     try {
53802       (arg1)->Connect(arg2,arg3);
53803     } catch (std::out_of_range& e) {
53804       {
53805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53806       };
53807     } catch (std::exception& e) {
53808       {
53809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53810       };
53811     } catch (Dali::DaliException e) {
53812       {
53813         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53814       };
53815     } catch (...) {
53816       {
53817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53818       };
53819     }
53820   }
53821
53822 }
53823
53824
53825 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Emit(void * jarg1) {
53826   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53827
53828   arg1 = (Dali::Signal< void () > *)jarg1;
53829   {
53830     try {
53831       (arg1)->Emit();
53832     } catch (std::out_of_range& e) {
53833       {
53834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53835       };
53836     } catch (std::exception& e) {
53837       {
53838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53839       };
53840     } catch (Dali::DaliException e) {
53841       {
53842         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53843       };
53844     } catch (...) {
53845       {
53846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53847       };
53848     }
53849   }
53850
53851 }
53852
53853
53854 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FloatSignal_Empty(void * jarg1) {
53855   unsigned int jresult ;
53856   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
53857   bool result;
53858
53859   arg1 = (Dali::Signal< void (float) > *)jarg1;
53860   {
53861     try {
53862       result = (bool)Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty((Dali::Signal< void (float) > const *)arg1);
53863     } catch (std::out_of_range& e) {
53864       {
53865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53866       };
53867     } catch (std::exception& e) {
53868       {
53869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53870       };
53871     } catch (Dali::DaliException e) {
53872       {
53873         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53874       };
53875     } catch (...) {
53876       {
53877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53878       };
53879     }
53880   }
53881
53882   jresult = result;
53883   return jresult;
53884 }
53885
53886
53887 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FloatSignal_GetConnectionCount(void * jarg1) {
53888   unsigned long jresult ;
53889   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
53890   std::size_t result;
53891
53892   arg1 = (Dali::Signal< void (float) > *)jarg1;
53893   {
53894     try {
53895       result = Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount((Dali::Signal< void (float) > const *)arg1);
53896     } catch (std::out_of_range& e) {
53897       {
53898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53899       };
53900     } catch (std::exception& e) {
53901       {
53902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53903       };
53904     } catch (Dali::DaliException e) {
53905       {
53906         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53907       };
53908     } catch (...) {
53909       {
53910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53911       };
53912     }
53913   }
53914
53915   jresult = (unsigned long)result;
53916   return jresult;
53917 }
53918
53919
53920 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Connect(void * jarg1, void * jarg2) {
53921   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
53922   void (*arg2)(float) = (void (*)(float)) 0 ;
53923
53924   arg1 = (Dali::Signal< void (float) > *)jarg1;
53925   arg2 = (void (*)(float))jarg2;
53926   {
53927     try {
53928       Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(arg1,arg2);
53929     } catch (std::out_of_range& e) {
53930       {
53931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53932       };
53933     } catch (std::exception& e) {
53934       {
53935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53936       };
53937     } catch (Dali::DaliException e) {
53938       {
53939         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53940       };
53941     } catch (...) {
53942       {
53943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53944       };
53945     }
53946   }
53947
53948 }
53949
53950
53951 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Disconnect(void * jarg1, void * jarg2) {
53952   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
53953   void (*arg2)(float) = (void (*)(float)) 0 ;
53954
53955   arg1 = (Dali::Signal< void (float) > *)jarg1;
53956   arg2 = (void (*)(float))jarg2;
53957   {
53958     try {
53959       Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(arg1,arg2);
53960     } catch (std::out_of_range& e) {
53961       {
53962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53963       };
53964     } catch (std::exception& e) {
53965       {
53966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53967       };
53968     } catch (Dali::DaliException e) {
53969       {
53970         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53971       };
53972     } catch (...) {
53973       {
53974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53975       };
53976     }
53977   }
53978
53979 }
53980
53981
53982 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Emit(void * jarg1, float jarg2) {
53983   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
53984   float arg2 ;
53985
53986   arg1 = (Dali::Signal< void (float) > *)jarg1;
53987   arg2 = (float)jarg2;
53988   {
53989     try {
53990       Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(arg1,arg2);
53991     } catch (std::out_of_range& e) {
53992       {
53993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53994       };
53995     } catch (std::exception& e) {
53996       {
53997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53998       };
53999     } catch (Dali::DaliException e) {
54000       {
54001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54002       };
54003     } catch (...) {
54004       {
54005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54006       };
54007     }
54008   }
54009
54010 }
54011
54012
54013 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FloatSignal() {
54014   void * jresult ;
54015   Dali::Signal< void (float) > *result = 0 ;
54016
54017   {
54018     try {
54019       result = (Dali::Signal< void (float) > *)new Dali::Signal< void (float) >();
54020     } catch (std::out_of_range& e) {
54021       {
54022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54023       };
54024     } catch (std::exception& e) {
54025       {
54026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54027       };
54028     } catch (Dali::DaliException e) {
54029       {
54030         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54031       };
54032     } catch (...) {
54033       {
54034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54035       };
54036     }
54037   }
54038
54039   jresult = (void *)result;
54040   return jresult;
54041 }
54042
54043
54044 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FloatSignal(void * jarg1) {
54045   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
54046
54047   arg1 = (Dali::Signal< void (float) > *)jarg1;
54048   {
54049     try {
54050       delete arg1;
54051     } catch (std::out_of_range& e) {
54052       {
54053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54054       };
54055     } catch (std::exception& e) {
54056       {
54057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54058       };
54059     } catch (Dali::DaliException e) {
54060       {
54061         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54062       };
54063     } catch (...) {
54064       {
54065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54066       };
54067     }
54068   }
54069
54070 }
54071
54072
54073 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Empty(void * jarg1) {
54074   unsigned int jresult ;
54075   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54076   bool result;
54077
54078   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54079   {
54080     try {
54081       result = (bool)Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
54082     } catch (std::out_of_range& e) {
54083       {
54084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54085       };
54086     } catch (std::exception& e) {
54087       {
54088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54089       };
54090     } catch (Dali::DaliException e) {
54091       {
54092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54093       };
54094     } catch (...) {
54095       {
54096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54097       };
54098     }
54099   }
54100
54101   jresult = result;
54102   return jresult;
54103 }
54104
54105
54106 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_GetConnectionCount(void * jarg1) {
54107   unsigned long jresult ;
54108   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54109   std::size_t result;
54110
54111   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54112   {
54113     try {
54114       result = Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
54115     } catch (std::out_of_range& e) {
54116       {
54117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54118       };
54119     } catch (std::exception& e) {
54120       {
54121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54122       };
54123     } catch (Dali::DaliException e) {
54124       {
54125         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54126       };
54127     } catch (...) {
54128       {
54129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54130       };
54131     }
54132   }
54133
54134   jresult = (unsigned long)result;
54135   return jresult;
54136 }
54137
54138
54139 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Connect(void * jarg1, void * jarg2) {
54140   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54141   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
54142
54143   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54144   arg2 = (void (*)(Dali::BaseHandle))jarg2;
54145   {
54146     try {
54147       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(arg1,arg2);
54148     } catch (std::out_of_range& e) {
54149       {
54150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54151       };
54152     } catch (std::exception& e) {
54153       {
54154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54155       };
54156     } catch (Dali::DaliException e) {
54157       {
54158         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54159       };
54160     } catch (...) {
54161       {
54162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54163       };
54164     }
54165   }
54166
54167 }
54168
54169
54170 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Disconnect(void * jarg1, void * jarg2) {
54171   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54172   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
54173
54174   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54175   arg2 = (void (*)(Dali::BaseHandle))jarg2;
54176   {
54177     try {
54178       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(arg1,arg2);
54179     } catch (std::out_of_range& e) {
54180       {
54181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54182       };
54183     } catch (std::exception& e) {
54184       {
54185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54186       };
54187     } catch (Dali::DaliException e) {
54188       {
54189         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54190       };
54191     } catch (...) {
54192       {
54193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54194       };
54195     }
54196   }
54197
54198 }
54199
54200
54201 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Emit(void * jarg1, void * jarg2) {
54202   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54203   Dali::BaseHandle arg2 ;
54204   Dali::BaseHandle *argp2 ;
54205
54206   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54207   argp2 = (Dali::BaseHandle *)jarg2;
54208   if (!argp2) {
54209     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
54210     return ;
54211   }
54212   arg2 = *argp2;
54213   {
54214     try {
54215       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(arg1,arg2);
54216     } catch (std::out_of_range& e) {
54217       {
54218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54219       };
54220     } catch (std::exception& e) {
54221       {
54222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54223       };
54224     } catch (Dali::DaliException e) {
54225       {
54226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54227       };
54228     } catch (...) {
54229       {
54230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54231       };
54232     }
54233   }
54234
54235 }
54236
54237
54238 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectCreatedSignal() {
54239   void * jresult ;
54240   Dali::Signal< void (Dali::BaseHandle) > *result = 0 ;
54241
54242   {
54243     try {
54244       result = (Dali::Signal< void (Dali::BaseHandle) > *)new Dali::Signal< void (Dali::BaseHandle) >();
54245     } catch (std::out_of_range& e) {
54246       {
54247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54248       };
54249     } catch (std::exception& e) {
54250       {
54251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54252       };
54253     } catch (Dali::DaliException e) {
54254       {
54255         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54256       };
54257     } catch (...) {
54258       {
54259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54260       };
54261     }
54262   }
54263
54264   jresult = (void *)result;
54265   return jresult;
54266 }
54267
54268
54269 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectCreatedSignal(void * jarg1) {
54270   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54271
54272   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54273   {
54274     try {
54275       delete arg1;
54276     } catch (std::out_of_range& e) {
54277       {
54278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54279       };
54280     } catch (std::exception& e) {
54281       {
54282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54283       };
54284     } catch (Dali::DaliException e) {
54285       {
54286         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54287       };
54288     } catch (...) {
54289       {
54290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54291       };
54292     }
54293   }
54294
54295 }
54296
54297
54298 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Empty(void * jarg1) {
54299   unsigned int jresult ;
54300   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54301   bool result;
54302
54303   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54304   {
54305     try {
54306       result = (bool)Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
54307     } catch (std::out_of_range& e) {
54308       {
54309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54310       };
54311     } catch (std::exception& e) {
54312       {
54313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54314       };
54315     } catch (Dali::DaliException e) {
54316       {
54317         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54318       };
54319     } catch (...) {
54320       {
54321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54322       };
54323     }
54324   }
54325
54326   jresult = result;
54327   return jresult;
54328 }
54329
54330
54331 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_GetConnectionCount(void * jarg1) {
54332   unsigned long jresult ;
54333   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54334   std::size_t result;
54335
54336   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54337   {
54338     try {
54339       result = Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
54340     } catch (std::out_of_range& e) {
54341       {
54342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54343       };
54344     } catch (std::exception& e) {
54345       {
54346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54347       };
54348     } catch (Dali::DaliException e) {
54349       {
54350         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54351       };
54352     } catch (...) {
54353       {
54354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54355       };
54356     }
54357   }
54358
54359   jresult = (unsigned long)result;
54360   return jresult;
54361 }
54362
54363
54364 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Connect(void * jarg1, void * jarg2) {
54365   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54366   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
54367
54368   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54369   arg2 = (void (*)(Dali::RefObject const *))jarg2;
54370   {
54371     try {
54372       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Connect(arg1,arg2);
54373     } catch (std::out_of_range& e) {
54374       {
54375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54376       };
54377     } catch (std::exception& e) {
54378       {
54379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54380       };
54381     } catch (Dali::DaliException e) {
54382       {
54383         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54384       };
54385     } catch (...) {
54386       {
54387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54388       };
54389     }
54390   }
54391
54392 }
54393
54394
54395 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Disconnect(void * jarg1, void * jarg2) {
54396   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54397   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
54398
54399   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54400   arg2 = (void (*)(Dali::RefObject const *))jarg2;
54401   {
54402     try {
54403       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Disconnect(arg1,arg2);
54404     } catch (std::out_of_range& e) {
54405       {
54406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54407       };
54408     } catch (std::exception& e) {
54409       {
54410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54411       };
54412     } catch (Dali::DaliException e) {
54413       {
54414         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54415       };
54416     } catch (...) {
54417       {
54418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54419       };
54420     }
54421   }
54422
54423 }
54424
54425
54426 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Emit(void * jarg1, void * jarg2) {
54427   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54428   Dali::RefObject *arg2 = (Dali::RefObject *) 0 ;
54429
54430   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54431   arg2 = (Dali::RefObject *)jarg2;
54432   {
54433     try {
54434       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Emit(arg1,(Dali::RefObject const *)arg2);
54435     } catch (std::out_of_range& e) {
54436       {
54437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54438       };
54439     } catch (std::exception& e) {
54440       {
54441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54442       };
54443     } catch (Dali::DaliException e) {
54444       {
54445         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54446       };
54447     } catch (...) {
54448       {
54449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54450       };
54451     }
54452   }
54453
54454 }
54455
54456
54457 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectDestroyedSignal() {
54458   void * jresult ;
54459   Dali::Signal< void (Dali::RefObject const *) > *result = 0 ;
54460
54461   {
54462     try {
54463       result = (Dali::Signal< void (Dali::RefObject const *) > *)new Dali::Signal< void (Dali::RefObject const *) >();
54464     } catch (std::out_of_range& e) {
54465       {
54466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54467       };
54468     } catch (std::exception& e) {
54469       {
54470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54471       };
54472     } catch (Dali::DaliException e) {
54473       {
54474         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54475       };
54476     } catch (...) {
54477       {
54478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54479       };
54480     }
54481   }
54482
54483   jresult = (void *)result;
54484   return jresult;
54485 }
54486
54487
54488 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectDestroyedSignal(void * jarg1) {
54489   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54490
54491   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54492   {
54493     try {
54494       delete arg1;
54495     } catch (std::out_of_range& e) {
54496       {
54497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54498       };
54499     } catch (std::exception& e) {
54500       {
54501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54502       };
54503     } catch (Dali::DaliException e) {
54504       {
54505         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54506       };
54507     } catch (...) {
54508       {
54509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54510       };
54511     }
54512   }
54513
54514 }
54515
54516
54517 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Empty(void * jarg1) {
54518   unsigned int jresult ;
54519   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54520   bool result;
54521
54522   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54523   {
54524     try {
54525       result = (bool)Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
54526     } catch (std::out_of_range& e) {
54527       {
54528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54529       };
54530     } catch (std::exception& e) {
54531       {
54532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54533       };
54534     } catch (Dali::DaliException e) {
54535       {
54536         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54537       };
54538     } catch (...) {
54539       {
54540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54541       };
54542     }
54543   }
54544
54545   jresult = result;
54546   return jresult;
54547 }
54548
54549
54550 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_GetConnectionCount(void * jarg1) {
54551   unsigned long jresult ;
54552   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54553   std::size_t result;
54554
54555   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54556   {
54557     try {
54558       result = Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
54559     } catch (std::out_of_range& e) {
54560       {
54561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54562       };
54563     } catch (std::exception& e) {
54564       {
54565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54566       };
54567     } catch (Dali::DaliException e) {
54568       {
54569         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54570       };
54571     } catch (...) {
54572       {
54573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54574       };
54575     }
54576   }
54577
54578   jresult = (unsigned long)result;
54579   return jresult;
54580 }
54581
54582
54583 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Connect(void * jarg1, void * jarg2) {
54584   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54585   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
54586
54587   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54588   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
54589   {
54590     try {
54591       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(arg1,arg2);
54592     } catch (std::out_of_range& e) {
54593       {
54594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54595       };
54596     } catch (std::exception& e) {
54597       {
54598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54599       };
54600     } catch (Dali::DaliException e) {
54601       {
54602         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54603       };
54604     } catch (...) {
54605       {
54606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54607       };
54608     }
54609   }
54610
54611 }
54612
54613
54614 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Disconnect(void * jarg1, void * jarg2) {
54615   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54616   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
54617
54618   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54619   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
54620   {
54621     try {
54622       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(arg1,arg2);
54623     } catch (std::out_of_range& e) {
54624       {
54625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54626       };
54627     } catch (std::exception& e) {
54628       {
54629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54630       };
54631     } catch (Dali::DaliException e) {
54632       {
54633         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54634       };
54635     } catch (...) {
54636       {
54637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54638       };
54639     }
54640   }
54641
54642 }
54643
54644
54645 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Emit(void * jarg1, void * jarg2) {
54646   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54647   Dali::PropertyNotification *arg2 = 0 ;
54648
54649   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54650   arg2 = (Dali::PropertyNotification *)jarg2;
54651   if (!arg2) {
54652     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification & type is null", 0);
54653     return ;
54654   }
54655   {
54656     try {
54657       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(arg1,*arg2);
54658     } catch (std::out_of_range& e) {
54659       {
54660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54661       };
54662     } catch (std::exception& e) {
54663       {
54664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54665       };
54666     } catch (Dali::DaliException e) {
54667       {
54668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54669       };
54670     } catch (...) {
54671       {
54672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54673       };
54674     }
54675   }
54676
54677 }
54678
54679
54680 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotifySignal() {
54681   void * jresult ;
54682   Dali::Signal< void (Dali::PropertyNotification &) > *result = 0 ;
54683
54684   {
54685     try {
54686       result = (Dali::Signal< void (Dali::PropertyNotification &) > *)new Dali::Signal< void (Dali::PropertyNotification &) >();
54687     } catch (std::out_of_range& e) {
54688       {
54689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54690       };
54691     } catch (std::exception& e) {
54692       {
54693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54694       };
54695     } catch (Dali::DaliException e) {
54696       {
54697         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54698       };
54699     } catch (...) {
54700       {
54701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54702       };
54703     }
54704   }
54705
54706   jresult = (void *)result;
54707   return jresult;
54708 }
54709
54710
54711 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotifySignal(void * jarg1) {
54712   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54713
54714   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54715   {
54716     try {
54717       delete arg1;
54718     } catch (std::out_of_range& e) {
54719       {
54720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54721       };
54722     } catch (std::exception& e) {
54723       {
54724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54725       };
54726     } catch (Dali::DaliException e) {
54727       {
54728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54729       };
54730     } catch (...) {
54731       {
54732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54733       };
54734     }
54735   }
54736
54737 }
54738
54739
54740 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ImageSignal_Empty(void * jarg1) {
54741   unsigned int jresult ;
54742   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54743   bool result;
54744
54745   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54746   {
54747     try {
54748       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Empty((Dali::Signal< void (Dali::Image) > const *)arg1);
54749     } catch (std::out_of_range& e) {
54750       {
54751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54752       };
54753     } catch (std::exception& e) {
54754       {
54755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54756       };
54757     } catch (Dali::DaliException e) {
54758       {
54759         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54760       };
54761     } catch (...) {
54762       {
54763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54764       };
54765     }
54766   }
54767
54768   jresult = result;
54769   return jresult;
54770 }
54771
54772
54773 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ImageSignal_GetConnectionCount(void * jarg1) {
54774   unsigned long jresult ;
54775   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54776   std::size_t result;
54777
54778   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54779   {
54780     try {
54781       result = Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Image) > const *)arg1);
54782     } catch (std::out_of_range& e) {
54783       {
54784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54785       };
54786     } catch (std::exception& e) {
54787       {
54788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54789       };
54790     } catch (Dali::DaliException e) {
54791       {
54792         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54793       };
54794     } catch (...) {
54795       {
54796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54797       };
54798     }
54799   }
54800
54801   jresult = (unsigned long)result;
54802   return jresult;
54803 }
54804
54805
54806 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Connect(void * jarg1, void * jarg2) {
54807   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54808   void (*arg2)(Dali::Image) = (void (*)(Dali::Image)) 0 ;
54809
54810   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54811   arg2 = (void (*)(Dali::Image))jarg2;
54812   {
54813     try {
54814       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Connect(arg1,arg2);
54815     } catch (std::out_of_range& e) {
54816       {
54817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54818       };
54819     } catch (std::exception& e) {
54820       {
54821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54822       };
54823     } catch (Dali::DaliException e) {
54824       {
54825         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54826       };
54827     } catch (...) {
54828       {
54829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54830       };
54831     }
54832   }
54833
54834 }
54835
54836
54837 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Disconnect(void * jarg1, void * jarg2) {
54838   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54839   void (*arg2)(Dali::Image) = (void (*)(Dali::Image)) 0 ;
54840
54841   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54842   arg2 = (void (*)(Dali::Image))jarg2;
54843   {
54844     try {
54845       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Disconnect(arg1,arg2);
54846     } catch (std::out_of_range& e) {
54847       {
54848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54849       };
54850     } catch (std::exception& e) {
54851       {
54852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54853       };
54854     } catch (Dali::DaliException e) {
54855       {
54856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54857       };
54858     } catch (...) {
54859       {
54860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54861       };
54862     }
54863   }
54864
54865 }
54866
54867
54868 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Emit(void * jarg1, void * jarg2) {
54869   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54870   Dali::Image arg2 ;
54871   Dali::Image *argp2 ;
54872
54873   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54874   argp2 = (Dali::Image *)jarg2;
54875   if (!argp2) {
54876     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
54877     return ;
54878   }
54879   arg2 = *argp2;
54880   {
54881     try {
54882       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Emit(arg1,arg2);
54883     } catch (std::out_of_range& e) {
54884       {
54885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54886       };
54887     } catch (std::exception& e) {
54888       {
54889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54890       };
54891     } catch (Dali::DaliException e) {
54892       {
54893         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54894       };
54895     } catch (...) {
54896       {
54897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54898       };
54899     }
54900   }
54901
54902 }
54903
54904
54905 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageSignal() {
54906   void * jresult ;
54907   Dali::Signal< void (Dali::Image) > *result = 0 ;
54908
54909   {
54910     try {
54911       result = (Dali::Signal< void (Dali::Image) > *)new Dali::Signal< void (Dali::Image) >();
54912     } catch (std::out_of_range& e) {
54913       {
54914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54915       };
54916     } catch (std::exception& e) {
54917       {
54918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54919       };
54920     } catch (Dali::DaliException e) {
54921       {
54922         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54923       };
54924     } catch (...) {
54925       {
54926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54927       };
54928     }
54929   }
54930
54931   jresult = (void *)result;
54932   return jresult;
54933 }
54934
54935
54936 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageSignal(void * jarg1) {
54937   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54938
54939   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54940   {
54941     try {
54942       delete arg1;
54943     } catch (std::out_of_range& e) {
54944       {
54945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54946       };
54947     } catch (std::exception& e) {
54948       {
54949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54950       };
54951     } catch (Dali::DaliException e) {
54952       {
54953         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54954       };
54955     } catch (...) {
54956       {
54957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54958       };
54959     }
54960   }
54961
54962 }
54963
54964
54965 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskSignal() {
54966   void * jresult ;
54967   Dali::Signal< void (Dali::RenderTask &) > *result = 0 ;
54968
54969   {
54970     try {
54971       result = (Dali::Signal< void (Dali::RenderTask &) > *)new Dali::Signal< void (Dali::RenderTask &) >();
54972     } catch (std::out_of_range& e) {
54973       {
54974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54975       };
54976     } catch (std::exception& e) {
54977       {
54978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54979       };
54980     } catch (Dali::DaliException e) {
54981       {
54982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54983       };
54984     } catch (...) {
54985       {
54986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54987       };
54988     }
54989   }
54990
54991   jresult = (void *)result;
54992   return jresult;
54993 }
54994
54995
54996 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskSignal(void * jarg1) {
54997   Dali::Signal< void (Dali::RenderTask &) > *arg1 = (Dali::Signal< void (Dali::RenderTask &) > *) 0 ;
54998
54999   arg1 = (Dali::Signal< void (Dali::RenderTask &) > *)jarg1;
55000   {
55001     try {
55002       delete arg1;
55003     } catch (std::out_of_range& e) {
55004       {
55005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55006       };
55007     } catch (std::exception& e) {
55008       {
55009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55010       };
55011     } catch (Dali::DaliException e) {
55012       {
55013         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55014       };
55015     } catch (...) {
55016       {
55017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55018       };
55019     }
55020   }
55021
55022 }
55023
55024
55025 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Empty(void * jarg1) {
55026   unsigned int jresult ;
55027   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55028   bool result;
55029
55030   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55031   {
55032     try {
55033       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);
55034     } catch (std::out_of_range& e) {
55035       {
55036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55037       };
55038     } catch (std::exception& e) {
55039       {
55040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55041       };
55042     } catch (Dali::DaliException e) {
55043       {
55044         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55045       };
55046     } catch (...) {
55047       {
55048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55049       };
55050     }
55051   }
55052
55053   jresult = result;
55054   return jresult;
55055 }
55056
55057
55058 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_GetConnectionCount(void * jarg1) {
55059   unsigned long jresult ;
55060   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55061   std::size_t result;
55062
55063   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55064   {
55065     try {
55066       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);
55067     } catch (std::out_of_range& e) {
55068       {
55069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55070       };
55071     } catch (std::exception& e) {
55072       {
55073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55074       };
55075     } catch (Dali::DaliException e) {
55076       {
55077         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55078       };
55079     } catch (...) {
55080       {
55081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55082       };
55083     }
55084   }
55085
55086   jresult = (unsigned long)result;
55087   return jresult;
55088 }
55089
55090
55091 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
55092   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55093   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
55094
55095   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55096   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
55097   {
55098     try {
55099       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
55100     } catch (std::out_of_range& e) {
55101       {
55102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55103       };
55104     } catch (std::exception& e) {
55105       {
55106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55107       };
55108     } catch (Dali::DaliException e) {
55109       {
55110         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55111       };
55112     } catch (...) {
55113       {
55114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55115       };
55116     }
55117   }
55118
55119 }
55120
55121
55122 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
55123   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55124   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
55125
55126   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55127   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
55128   {
55129     try {
55130       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
55131     } catch (std::out_of_range& e) {
55132       {
55133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55134       };
55135     } catch (std::exception& e) {
55136       {
55137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55138       };
55139     } catch (Dali::DaliException e) {
55140       {
55141         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55142       };
55143     } catch (...) {
55144       {
55145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55146       };
55147     }
55148   }
55149
55150 }
55151
55152
55153 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
55154   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55155   Dali::Actor arg2 ;
55156   Dali::LongPressGesture *arg3 = 0 ;
55157   Dali::Actor *argp2 ;
55158
55159   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55160   argp2 = (Dali::Actor *)jarg2;
55161   if (!argp2) {
55162     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55163     return ;
55164   }
55165   arg2 = *argp2;
55166   arg3 = (Dali::LongPressGesture *)jarg3;
55167   if (!arg3) {
55168     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
55169     return ;
55170   }
55171   {
55172     try {
55173       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::LongPressGesture const &)*arg3);
55174     } catch (std::out_of_range& e) {
55175       {
55176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55177       };
55178     } catch (std::exception& e) {
55179       {
55180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55181       };
55182     } catch (Dali::DaliException e) {
55183       {
55184         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55185       };
55186     } catch (...) {
55187       {
55188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55189       };
55190     }
55191   }
55192
55193 }
55194
55195
55196 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetectedSignal() {
55197   void * jresult ;
55198   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *result = 0 ;
55199
55200   {
55201     try {
55202       result = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) >();
55203     } catch (std::out_of_range& e) {
55204       {
55205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55206       };
55207     } catch (std::exception& e) {
55208       {
55209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55210       };
55211     } catch (Dali::DaliException e) {
55212       {
55213         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55214       };
55215     } catch (...) {
55216       {
55217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55218       };
55219     }
55220   }
55221
55222   jresult = (void *)result;
55223   return jresult;
55224 }
55225
55226
55227 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetectedSignal(void * jarg1) {
55228   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55229
55230   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55231   {
55232     try {
55233       delete arg1;
55234     } catch (std::out_of_range& e) {
55235       {
55236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55237       };
55238     } catch (std::exception& e) {
55239       {
55240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55241       };
55242     } catch (Dali::DaliException e) {
55243       {
55244         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55245       };
55246     } catch (...) {
55247       {
55248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55249       };
55250     }
55251   }
55252
55253 }
55254
55255
55256 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Empty(void * jarg1) {
55257   unsigned int jresult ;
55258   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55259   bool result;
55260
55261   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55262   {
55263     try {
55264       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);
55265     } catch (std::out_of_range& e) {
55266       {
55267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55268       };
55269     } catch (std::exception& e) {
55270       {
55271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55272       };
55273     } catch (Dali::DaliException e) {
55274       {
55275         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55276       };
55277     } catch (...) {
55278       {
55279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55280       };
55281     }
55282   }
55283
55284   jresult = result;
55285   return jresult;
55286 }
55287
55288
55289 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_GetConnectionCount(void * jarg1) {
55290   unsigned long jresult ;
55291   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55292   std::size_t result;
55293
55294   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55295   {
55296     try {
55297       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);
55298     } catch (std::out_of_range& e) {
55299       {
55300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55301       };
55302     } catch (std::exception& e) {
55303       {
55304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55305       };
55306     } catch (Dali::DaliException e) {
55307       {
55308         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55309       };
55310     } catch (...) {
55311       {
55312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55313       };
55314     }
55315   }
55316
55317   jresult = (unsigned long)result;
55318   return jresult;
55319 }
55320
55321
55322 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Connect(void * jarg1, void * jarg2) {
55323   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55324   bool (*arg2)(Dali::Actor,Dali::TouchData const &) = (bool (*)(Dali::Actor,Dali::TouchData const &)) 0 ;
55325
55326   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55327   arg2 = (bool (*)(Dali::Actor,Dali::TouchData const &))jarg2;
55328   {
55329     try {
55330       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Connect(arg1,arg2);
55331     } catch (std::out_of_range& e) {
55332       {
55333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55334       };
55335     } catch (std::exception& e) {
55336       {
55337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55338       };
55339     } catch (Dali::DaliException e) {
55340       {
55341         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55342       };
55343     } catch (...) {
55344       {
55345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55346       };
55347     }
55348   }
55349
55350 }
55351
55352
55353 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Disconnect(void * jarg1, void * jarg2) {
55354   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55355   bool (*arg2)(Dali::Actor,Dali::TouchData const &) = (bool (*)(Dali::Actor,Dali::TouchData const &)) 0 ;
55356
55357   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55358   arg2 = (bool (*)(Dali::Actor,Dali::TouchData const &))jarg2;
55359   {
55360     try {
55361       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
55362     } catch (std::out_of_range& e) {
55363       {
55364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55365       };
55366     } catch (std::exception& e) {
55367       {
55368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55369       };
55370     } catch (Dali::DaliException e) {
55371       {
55372         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55373       };
55374     } catch (...) {
55375       {
55376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55377       };
55378     }
55379   }
55380
55381 }
55382
55383
55384 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
55385   unsigned int jresult ;
55386   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55387   Dali::Actor arg2 ;
55388   Dali::TouchData *arg3 = 0 ;
55389   Dali::Actor *argp2 ;
55390   bool result;
55391
55392   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55393   argp2 = (Dali::Actor *)jarg2;
55394   if (!argp2) {
55395     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55396     return 0;
55397   }
55398   arg2 = *argp2;
55399   arg3 = (Dali::TouchData *)jarg3;
55400   if (!arg3) {
55401     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
55402     return 0;
55403   }
55404   {
55405     try {
55406       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TouchData const &)*arg3);
55407     } catch (std::out_of_range& e) {
55408       {
55409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55410       };
55411     } catch (std::exception& e) {
55412       {
55413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55414       };
55415     } catch (Dali::DaliException e) {
55416       {
55417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55418       };
55419     } catch (...) {
55420       {
55421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55422       };
55423     }
55424   }
55425
55426   jresult = result;
55427   return jresult;
55428 }
55429
55430
55431 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorTouchDataSignal() {
55432   void * jresult ;
55433   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *result = 0 ;
55434
55435   {
55436     try {
55437       result = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) >();
55438     } catch (std::out_of_range& e) {
55439       {
55440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55441       };
55442     } catch (std::exception& e) {
55443       {
55444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55445       };
55446     } catch (Dali::DaliException e) {
55447       {
55448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55449       };
55450     } catch (...) {
55451       {
55452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55453       };
55454     }
55455   }
55456
55457   jresult = (void *)result;
55458   return jresult;
55459 }
55460
55461
55462 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorTouchDataSignal(void * jarg1) {
55463   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55464
55465   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55466   {
55467     try {
55468       delete arg1;
55469     } catch (std::out_of_range& e) {
55470       {
55471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55472       };
55473     } catch (std::exception& e) {
55474       {
55475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55476       };
55477     } catch (Dali::DaliException e) {
55478       {
55479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55480       };
55481     } catch (...) {
55482       {
55483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55484       };
55485     }
55486   }
55487
55488 }
55489
55490
55491 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Empty(void * jarg1) {
55492   unsigned int jresult ;
55493   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55494   bool result;
55495
55496   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55497   {
55498     try {
55499       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);
55500     } catch (std::out_of_range& e) {
55501       {
55502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55503       };
55504     } catch (std::exception& e) {
55505       {
55506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55507       };
55508     } catch (Dali::DaliException e) {
55509       {
55510         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55511       };
55512     } catch (...) {
55513       {
55514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55515       };
55516     }
55517   }
55518
55519   jresult = result;
55520   return jresult;
55521 }
55522
55523
55524 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorHoverSignal_GetConnectionCount(void * jarg1) {
55525   unsigned long jresult ;
55526   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55527   std::size_t result;
55528
55529   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55530   {
55531     try {
55532       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);
55533     } catch (std::out_of_range& e) {
55534       {
55535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55536       };
55537     } catch (std::exception& e) {
55538       {
55539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55540       };
55541     } catch (Dali::DaliException e) {
55542       {
55543         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55544       };
55545     } catch (...) {
55546       {
55547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55548       };
55549     }
55550   }
55551
55552   jresult = (unsigned long)result;
55553   return jresult;
55554 }
55555
55556
55557 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Connect(void * jarg1, void * jarg2) {
55558   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55559   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
55560
55561   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55562   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
55563   {
55564     try {
55565       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
55566     } catch (std::out_of_range& e) {
55567       {
55568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55569       };
55570     } catch (std::exception& e) {
55571       {
55572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55573       };
55574     } catch (Dali::DaliException e) {
55575       {
55576         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55577       };
55578     } catch (...) {
55579       {
55580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55581       };
55582     }
55583   }
55584
55585 }
55586
55587
55588 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Disconnect(void * jarg1, void * jarg2) {
55589   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55590   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
55591
55592   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55593   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
55594   {
55595     try {
55596       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
55597     } catch (std::out_of_range& e) {
55598       {
55599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55600       };
55601     } catch (std::exception& e) {
55602       {
55603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55604       };
55605     } catch (Dali::DaliException e) {
55606       {
55607         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55608       };
55609     } catch (...) {
55610       {
55611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55612       };
55613     }
55614   }
55615
55616 }
55617
55618
55619 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
55620   unsigned int jresult ;
55621   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55622   Dali::Actor arg2 ;
55623   Dali::HoverEvent *arg3 = 0 ;
55624   Dali::Actor *argp2 ;
55625   bool result;
55626
55627   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55628   argp2 = (Dali::Actor *)jarg2;
55629   if (!argp2) {
55630     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55631     return 0;
55632   }
55633   arg2 = *argp2;
55634   arg3 = (Dali::HoverEvent *)jarg3;
55635   if (!arg3) {
55636     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
55637     return 0;
55638   }
55639   {
55640     try {
55641       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::HoverEvent const &)*arg3);
55642     } catch (std::out_of_range& e) {
55643       {
55644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55645       };
55646     } catch (std::exception& e) {
55647       {
55648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55649       };
55650     } catch (Dali::DaliException e) {
55651       {
55652         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55653       };
55654     } catch (...) {
55655       {
55656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55657       };
55658     }
55659   }
55660
55661   jresult = result;
55662   return jresult;
55663 }
55664
55665
55666 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorHoverSignal() {
55667   void * jresult ;
55668   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *result = 0 ;
55669
55670   {
55671     try {
55672       result = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) >();
55673     } catch (std::out_of_range& e) {
55674       {
55675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55676       };
55677     } catch (std::exception& e) {
55678       {
55679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55680       };
55681     } catch (Dali::DaliException e) {
55682       {
55683         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55684       };
55685     } catch (...) {
55686       {
55687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55688       };
55689     }
55690   }
55691
55692   jresult = (void *)result;
55693   return jresult;
55694 }
55695
55696
55697 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorHoverSignal(void * jarg1) {
55698   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55699
55700   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55701   {
55702     try {
55703       delete arg1;
55704     } catch (std::out_of_range& e) {
55705       {
55706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55707       };
55708     } catch (std::exception& e) {
55709       {
55710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55711       };
55712     } catch (Dali::DaliException e) {
55713       {
55714         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55715       };
55716     } catch (...) {
55717       {
55718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55719       };
55720     }
55721   }
55722
55723 }
55724
55725
55726 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Empty(void * jarg1) {
55727   unsigned int jresult ;
55728   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55729   bool result;
55730
55731   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55732   {
55733     try {
55734       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);
55735     } catch (std::out_of_range& e) {
55736       {
55737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55738       };
55739     } catch (std::exception& e) {
55740       {
55741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55742       };
55743     } catch (Dali::DaliException e) {
55744       {
55745         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55746       };
55747     } catch (...) {
55748       {
55749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55750       };
55751     }
55752   }
55753
55754   jresult = result;
55755   return jresult;
55756 }
55757
55758
55759 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorWheelSignal_GetConnectionCount(void * jarg1) {
55760   unsigned long jresult ;
55761   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55762   std::size_t result;
55763
55764   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55765   {
55766     try {
55767       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);
55768     } catch (std::out_of_range& e) {
55769       {
55770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55771       };
55772     } catch (std::exception& e) {
55773       {
55774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55775       };
55776     } catch (Dali::DaliException e) {
55777       {
55778         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55779       };
55780     } catch (...) {
55781       {
55782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55783       };
55784     }
55785   }
55786
55787   jresult = (unsigned long)result;
55788   return jresult;
55789 }
55790
55791
55792 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Connect(void * jarg1, void * jarg2) {
55793   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55794   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
55795
55796   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55797   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
55798   {
55799     try {
55800       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
55801     } catch (std::out_of_range& e) {
55802       {
55803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55804       };
55805     } catch (std::exception& e) {
55806       {
55807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55808       };
55809     } catch (Dali::DaliException e) {
55810       {
55811         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55812       };
55813     } catch (...) {
55814       {
55815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55816       };
55817     }
55818   }
55819
55820 }
55821
55822
55823 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Disconnect(void * jarg1, void * jarg2) {
55824   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55825   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
55826
55827   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55828   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
55829   {
55830     try {
55831       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
55832     } catch (std::out_of_range& e) {
55833       {
55834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55835       };
55836     } catch (std::exception& e) {
55837       {
55838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55839       };
55840     } catch (Dali::DaliException e) {
55841       {
55842         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55843       };
55844     } catch (...) {
55845       {
55846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55847       };
55848     }
55849   }
55850
55851 }
55852
55853
55854 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
55855   unsigned int jresult ;
55856   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55857   Dali::Actor arg2 ;
55858   Dali::WheelEvent *arg3 = 0 ;
55859   Dali::Actor *argp2 ;
55860   bool result;
55861
55862   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55863   argp2 = (Dali::Actor *)jarg2;
55864   if (!argp2) {
55865     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55866     return 0;
55867   }
55868   arg2 = *argp2;
55869   arg3 = (Dali::WheelEvent *)jarg3;
55870   if (!arg3) {
55871     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
55872     return 0;
55873   }
55874   {
55875     try {
55876       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::WheelEvent const &)*arg3);
55877     } catch (std::out_of_range& e) {
55878       {
55879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55880       };
55881     } catch (std::exception& e) {
55882       {
55883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55884       };
55885     } catch (Dali::DaliException e) {
55886       {
55887         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55888       };
55889     } catch (...) {
55890       {
55891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55892       };
55893     }
55894   }
55895
55896   jresult = result;
55897   return jresult;
55898 }
55899
55900
55901 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorWheelSignal() {
55902   void * jresult ;
55903   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *result = 0 ;
55904
55905   {
55906     try {
55907       result = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) >();
55908     } catch (std::out_of_range& e) {
55909       {
55910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55911       };
55912     } catch (std::exception& e) {
55913       {
55914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55915       };
55916     } catch (Dali::DaliException e) {
55917       {
55918         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55919       };
55920     } catch (...) {
55921       {
55922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55923       };
55924     }
55925   }
55926
55927   jresult = (void *)result;
55928   return jresult;
55929 }
55930
55931
55932 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorWheelSignal(void * jarg1) {
55933   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55934
55935   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55936   {
55937     try {
55938       delete arg1;
55939     } catch (std::out_of_range& e) {
55940       {
55941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55942       };
55943     } catch (std::exception& e) {
55944       {
55945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55946       };
55947     } catch (Dali::DaliException e) {
55948       {
55949         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55950       };
55951     } catch (...) {
55952       {
55953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55954       };
55955     }
55956   }
55957
55958 }
55959
55960
55961 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorSignal_Empty(void * jarg1) {
55962   unsigned int jresult ;
55963   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
55964   bool result;
55965
55966   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
55967   {
55968     try {
55969       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor) > const *)arg1);
55970     } catch (std::out_of_range& e) {
55971       {
55972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55973       };
55974     } catch (std::exception& e) {
55975       {
55976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55977       };
55978     } catch (Dali::DaliException e) {
55979       {
55980         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55981       };
55982     } catch (...) {
55983       {
55984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55985       };
55986     }
55987   }
55988
55989   jresult = result;
55990   return jresult;
55991 }
55992
55993
55994 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorSignal_GetConnectionCount(void * jarg1) {
55995   unsigned long jresult ;
55996   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
55997   std::size_t result;
55998
55999   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56000   {
56001     try {
56002       result = Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor) > const *)arg1);
56003     } catch (std::out_of_range& e) {
56004       {
56005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56006       };
56007     } catch (std::exception& e) {
56008       {
56009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56010       };
56011     } catch (Dali::DaliException e) {
56012       {
56013         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56014       };
56015     } catch (...) {
56016       {
56017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56018       };
56019     }
56020   }
56021
56022   jresult = (unsigned long)result;
56023   return jresult;
56024 }
56025
56026
56027 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Connect(void * jarg1, void * jarg2) {
56028   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56029   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
56030
56031   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56032   arg2 = (void (*)(Dali::Actor))jarg2;
56033   {
56034     try {
56035       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(arg1,arg2);
56036     } catch (std::out_of_range& e) {
56037       {
56038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56039       };
56040     } catch (std::exception& e) {
56041       {
56042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56043       };
56044     } catch (Dali::DaliException e) {
56045       {
56046         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56047       };
56048     } catch (...) {
56049       {
56050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56051       };
56052     }
56053   }
56054
56055 }
56056
56057
56058 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Disconnect(void * jarg1, void * jarg2) {
56059   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56060   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
56061
56062   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56063   arg2 = (void (*)(Dali::Actor))jarg2;
56064   {
56065     try {
56066       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
56067     } catch (std::out_of_range& e) {
56068       {
56069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56070       };
56071     } catch (std::exception& e) {
56072       {
56073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56074       };
56075     } catch (Dali::DaliException e) {
56076       {
56077         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56078       };
56079     } catch (...) {
56080       {
56081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56082       };
56083     }
56084   }
56085
56086 }
56087
56088
56089 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Emit(void * jarg1, void * jarg2) {
56090   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56091   Dali::Actor arg2 ;
56092   Dali::Actor *argp2 ;
56093
56094   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56095   argp2 = (Dali::Actor *)jarg2;
56096   if (!argp2) {
56097     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
56098     return ;
56099   }
56100   arg2 = *argp2;
56101   {
56102     try {
56103       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(arg1,arg2);
56104     } catch (std::out_of_range& e) {
56105       {
56106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56107       };
56108     } catch (std::exception& e) {
56109       {
56110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56111       };
56112     } catch (Dali::DaliException e) {
56113       {
56114         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56115       };
56116     } catch (...) {
56117       {
56118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56119       };
56120     }
56121   }
56122
56123 }
56124
56125
56126 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorSignal() {
56127   void * jresult ;
56128   Dali::Signal< void (Dali::Actor) > *result = 0 ;
56129
56130   {
56131     try {
56132       result = (Dali::Signal< void (Dali::Actor) > *)new Dali::Signal< void (Dali::Actor) >();
56133     } catch (std::out_of_range& e) {
56134       {
56135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56136       };
56137     } catch (std::exception& e) {
56138       {
56139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56140       };
56141     } catch (Dali::DaliException e) {
56142       {
56143         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56144       };
56145     } catch (...) {
56146       {
56147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56148       };
56149     }
56150   }
56151
56152   jresult = (void *)result;
56153   return jresult;
56154 }
56155
56156
56157 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorSignal(void * jarg1) {
56158   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56159
56160   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56161   {
56162     try {
56163       delete arg1;
56164     } catch (std::out_of_range& e) {
56165       {
56166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56167       };
56168     } catch (std::exception& e) {
56169       {
56170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56171       };
56172     } catch (Dali::DaliException e) {
56173       {
56174         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56175       };
56176     } catch (...) {
56177       {
56178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56179       };
56180     }
56181   }
56182
56183 }
56184
56185
56186 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyEventSignal_Empty(void * jarg1) {
56187   unsigned int jresult ;
56188   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56189   bool result;
56190
56191   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56192   {
56193     try {
56194       result = (bool)Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
56195     } catch (std::out_of_range& e) {
56196       {
56197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56198       };
56199     } catch (std::exception& e) {
56200       {
56201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56202       };
56203     } catch (Dali::DaliException e) {
56204       {
56205         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56206       };
56207     } catch (...) {
56208       {
56209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56210       };
56211     }
56212   }
56213
56214   jresult = result;
56215   return jresult;
56216 }
56217
56218
56219 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyEventSignal_GetConnectionCount(void * jarg1) {
56220   unsigned long jresult ;
56221   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56222   std::size_t result;
56223
56224   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56225   {
56226     try {
56227       result = Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
56228     } catch (std::out_of_range& e) {
56229       {
56230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56231       };
56232     } catch (std::exception& e) {
56233       {
56234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56235       };
56236     } catch (Dali::DaliException e) {
56237       {
56238         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56239       };
56240     } catch (...) {
56241       {
56242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56243       };
56244     }
56245   }
56246
56247   jresult = (unsigned long)result;
56248   return jresult;
56249 }
56250
56251
56252 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Connect(void * jarg1, void * jarg2) {
56253   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56254   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
56255
56256   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56257   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
56258   {
56259     try {
56260       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
56261     } catch (std::out_of_range& e) {
56262       {
56263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56264       };
56265     } catch (std::exception& e) {
56266       {
56267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56268       };
56269     } catch (Dali::DaliException e) {
56270       {
56271         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56272       };
56273     } catch (...) {
56274       {
56275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56276       };
56277     }
56278   }
56279
56280 }
56281
56282
56283 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Disconnect(void * jarg1, void * jarg2) {
56284   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56285   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
56286
56287   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56288   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
56289   {
56290     try {
56291       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
56292     } catch (std::out_of_range& e) {
56293       {
56294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56295       };
56296     } catch (std::exception& e) {
56297       {
56298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56299       };
56300     } catch (Dali::DaliException e) {
56301       {
56302         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56303       };
56304     } catch (...) {
56305       {
56306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56307       };
56308     }
56309   }
56310
56311 }
56312
56313
56314 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Emit(void * jarg1, void * jarg2) {
56315   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56316   Dali::KeyEvent *arg2 = 0 ;
56317
56318   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56319   arg2 = (Dali::KeyEvent *)jarg2;
56320   if (!arg2) {
56321     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
56322     return ;
56323   }
56324   {
56325     try {
56326       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::KeyEvent const &)*arg2);
56327     } catch (std::out_of_range& e) {
56328       {
56329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56330       };
56331     } catch (std::exception& e) {
56332       {
56333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56334       };
56335     } catch (Dali::DaliException e) {
56336       {
56337         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56338       };
56339     } catch (...) {
56340       {
56341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56342       };
56343     }
56344   }
56345
56346 }
56347
56348
56349 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyEventSignal() {
56350   void * jresult ;
56351   Dali::Signal< void (Dali::KeyEvent const &) > *result = 0 ;
56352
56353   {
56354     try {
56355       result = (Dali::Signal< void (Dali::KeyEvent const &) > *)new Dali::Signal< void (Dali::KeyEvent const &) >();
56356     } catch (std::out_of_range& e) {
56357       {
56358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56359       };
56360     } catch (std::exception& e) {
56361       {
56362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56363       };
56364     } catch (Dali::DaliException e) {
56365       {
56366         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56367       };
56368     } catch (...) {
56369       {
56370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56371       };
56372     }
56373   }
56374
56375   jresult = (void *)result;
56376   return jresult;
56377 }
56378
56379
56380 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyEventSignal(void * jarg1) {
56381   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56382
56383   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56384   {
56385     try {
56386       delete arg1;
56387     } catch (std::out_of_range& e) {
56388       {
56389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56390       };
56391     } catch (std::exception& e) {
56392       {
56393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56394       };
56395     } catch (Dali::DaliException e) {
56396       {
56397         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56398       };
56399     } catch (...) {
56400       {
56401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56402       };
56403     }
56404   }
56405
56406 }
56407
56408
56409 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TouchSignal_Empty(void * jarg1) {
56410   unsigned int jresult ;
56411   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56412   bool result;
56413
56414   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56415   {
56416     try {
56417       result = (bool)Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::TouchData const &) > const *)arg1);
56418     } catch (std::out_of_range& e) {
56419       {
56420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56421       };
56422     } catch (std::exception& e) {
56423       {
56424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56425       };
56426     } catch (Dali::DaliException e) {
56427       {
56428         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56429       };
56430     } catch (...) {
56431       {
56432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56433       };
56434     }
56435   }
56436
56437   jresult = result;
56438   return jresult;
56439 }
56440
56441
56442 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchSignal_GetConnectionCount(void * jarg1) {
56443   unsigned long jresult ;
56444   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56445   std::size_t result;
56446
56447   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56448   {
56449     try {
56450       result = Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::TouchData const &) > const *)arg1);
56451     } catch (std::out_of_range& e) {
56452       {
56453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56454       };
56455     } catch (std::exception& e) {
56456       {
56457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56458       };
56459     } catch (Dali::DaliException e) {
56460       {
56461         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56462       };
56463     } catch (...) {
56464       {
56465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56466       };
56467     }
56468   }
56469
56470   jresult = (unsigned long)result;
56471   return jresult;
56472 }
56473
56474
56475 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Connect(void * jarg1, void * jarg2) {
56476   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56477   void (*arg2)(Dali::TouchData const &) = (void (*)(Dali::TouchData const &)) 0 ;
56478
56479   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56480   arg2 = (void (*)(Dali::TouchData const &))jarg2;
56481   {
56482     try {
56483       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Connect(arg1,arg2);
56484     } catch (std::out_of_range& e) {
56485       {
56486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56487       };
56488     } catch (std::exception& e) {
56489       {
56490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56491       };
56492     } catch (Dali::DaliException e) {
56493       {
56494         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56495       };
56496     } catch (...) {
56497       {
56498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56499       };
56500     }
56501   }
56502
56503 }
56504
56505
56506 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Disconnect(void * jarg1, void * jarg2) {
56507   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56508   void (*arg2)(Dali::TouchData const &) = (void (*)(Dali::TouchData const &)) 0 ;
56509
56510   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56511   arg2 = (void (*)(Dali::TouchData const &))jarg2;
56512   {
56513     try {
56514       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
56515     } catch (std::out_of_range& e) {
56516       {
56517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56518       };
56519     } catch (std::exception& e) {
56520       {
56521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56522       };
56523     } catch (Dali::DaliException e) {
56524       {
56525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56526       };
56527     } catch (...) {
56528       {
56529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56530       };
56531     }
56532   }
56533
56534 }
56535
56536
56537 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Emit(void * jarg1, void * jarg2) {
56538   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56539   Dali::TouchData *arg2 = 0 ;
56540
56541   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56542   arg2 = (Dali::TouchData *)jarg2;
56543   if (!arg2) {
56544     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
56545     return ;
56546   }
56547   {
56548     try {
56549       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Emit(arg1,(Dali::TouchData const &)*arg2);
56550     } catch (std::out_of_range& e) {
56551       {
56552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56553       };
56554     } catch (std::exception& e) {
56555       {
56556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56557       };
56558     } catch (Dali::DaliException e) {
56559       {
56560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56561       };
56562     } catch (...) {
56563       {
56564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56565       };
56566     }
56567   }
56568
56569 }
56570
56571
56572 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchSignal() {
56573   void * jresult ;
56574   Dali::Signal< void (Dali::TouchData const &) > *result = 0 ;
56575
56576   {
56577     try {
56578       result = (Dali::Signal< void (Dali::TouchData const &) > *)new Dali::Signal< void (Dali::TouchData const &) >();
56579     } catch (std::out_of_range& e) {
56580       {
56581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56582       };
56583     } catch (std::exception& e) {
56584       {
56585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56586       };
56587     } catch (Dali::DaliException e) {
56588       {
56589         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56590       };
56591     } catch (...) {
56592       {
56593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56594       };
56595     }
56596   }
56597
56598   jresult = (void *)result;
56599   return jresult;
56600 }
56601
56602
56603 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchSignal(void * jarg1) {
56604   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56605
56606   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56607   {
56608     try {
56609       delete arg1;
56610     } catch (std::out_of_range& e) {
56611       {
56612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56613       };
56614     } catch (std::exception& e) {
56615       {
56616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56617       };
56618     } catch (Dali::DaliException e) {
56619       {
56620         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56621       };
56622     } catch (...) {
56623       {
56624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56625       };
56626     }
56627   }
56628
56629 }
56630
56631
56632 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StageWheelSignal_Empty(void * jarg1) {
56633   unsigned int jresult ;
56634   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56635   bool result;
56636
56637   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56638   {
56639     try {
56640       result = (bool)Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
56641     } catch (std::out_of_range& e) {
56642       {
56643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56644       };
56645     } catch (std::exception& e) {
56646       {
56647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56648       };
56649     } catch (Dali::DaliException e) {
56650       {
56651         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56652       };
56653     } catch (...) {
56654       {
56655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56656       };
56657     }
56658   }
56659
56660   jresult = result;
56661   return jresult;
56662 }
56663
56664
56665 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StageWheelSignal_GetConnectionCount(void * jarg1) {
56666   unsigned long jresult ;
56667   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56668   std::size_t result;
56669
56670   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56671   {
56672     try {
56673       result = Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
56674     } catch (std::out_of_range& e) {
56675       {
56676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56677       };
56678     } catch (std::exception& e) {
56679       {
56680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56681       };
56682     } catch (Dali::DaliException e) {
56683       {
56684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56685       };
56686     } catch (...) {
56687       {
56688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56689       };
56690     }
56691   }
56692
56693   jresult = (unsigned long)result;
56694   return jresult;
56695 }
56696
56697
56698 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Connect(void * jarg1, void * jarg2) {
56699   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56700   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
56701
56702   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56703   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
56704   {
56705     try {
56706       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
56707     } catch (std::out_of_range& e) {
56708       {
56709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56710       };
56711     } catch (std::exception& e) {
56712       {
56713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56714       };
56715     } catch (Dali::DaliException e) {
56716       {
56717         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56718       };
56719     } catch (...) {
56720       {
56721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56722       };
56723     }
56724   }
56725
56726 }
56727
56728
56729 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Disconnect(void * jarg1, void * jarg2) {
56730   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56731   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
56732
56733   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56734   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
56735   {
56736     try {
56737       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
56738     } catch (std::out_of_range& e) {
56739       {
56740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56741       };
56742     } catch (std::exception& e) {
56743       {
56744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56745       };
56746     } catch (Dali::DaliException e) {
56747       {
56748         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56749       };
56750     } catch (...) {
56751       {
56752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56753       };
56754     }
56755   }
56756
56757 }
56758
56759
56760 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Emit(void * jarg1, void * jarg2) {
56761   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56762   Dali::WheelEvent *arg2 = 0 ;
56763
56764   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56765   arg2 = (Dali::WheelEvent *)jarg2;
56766   if (!arg2) {
56767     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
56768     return ;
56769   }
56770   {
56771     try {
56772       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::WheelEvent const &)*arg2);
56773     } catch (std::out_of_range& e) {
56774       {
56775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56776       };
56777     } catch (std::exception& e) {
56778       {
56779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56780       };
56781     } catch (Dali::DaliException e) {
56782       {
56783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56784       };
56785     } catch (...) {
56786       {
56787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56788       };
56789     }
56790   }
56791
56792 }
56793
56794
56795 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StageWheelSignal() {
56796   void * jresult ;
56797   Dali::Signal< void (Dali::WheelEvent const &) > *result = 0 ;
56798
56799   {
56800     try {
56801       result = (Dali::Signal< void (Dali::WheelEvent const &) > *)new Dali::Signal< void (Dali::WheelEvent const &) >();
56802     } catch (std::out_of_range& e) {
56803       {
56804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56805       };
56806     } catch (std::exception& e) {
56807       {
56808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56809       };
56810     } catch (Dali::DaliException e) {
56811       {
56812         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56813       };
56814     } catch (...) {
56815       {
56816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56817       };
56818     }
56819   }
56820
56821   jresult = (void *)result;
56822   return jresult;
56823 }
56824
56825
56826 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StageWheelSignal(void * jarg1) {
56827   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56828
56829   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56830   {
56831     try {
56832       delete arg1;
56833     } catch (std::out_of_range& e) {
56834       {
56835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56836       };
56837     } catch (std::exception& e) {
56838       {
56839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56840       };
56841     } catch (Dali::DaliException e) {
56842       {
56843         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56844       };
56845     } catch (...) {
56846       {
56847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56848       };
56849     }
56850   }
56851
56852 }
56853
56854
56855 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_0() {
56856   void * jresult ;
56857   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
56858
56859   {
56860     try {
56861       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >();
56862     } catch (std::out_of_range& e) {
56863       {
56864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56865       };
56866     } catch (std::exception& e) {
56867       {
56868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56869       };
56870     } catch (Dali::DaliException e) {
56871       {
56872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56873       };
56874     } catch (...) {
56875       {
56876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56877       };
56878     }
56879   }
56880
56881   jresult = (void *)result;
56882   return jresult;
56883 }
56884
56885
56886 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_1(void * jarg1, void * jarg2) {
56887   void * jresult ;
56888   Dali::Radian arg1 ;
56889   Dali::Radian arg2 ;
56890   Dali::Radian *argp1 ;
56891   Dali::Radian *argp2 ;
56892   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
56893
56894   argp1 = (Dali::Radian *)jarg1;
56895   if (!argp1) {
56896     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
56897     return 0;
56898   }
56899   arg1 = *argp1;
56900   argp2 = (Dali::Radian *)jarg2;
56901   if (!argp2) {
56902     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
56903     return 0;
56904   }
56905   arg2 = *argp2;
56906   {
56907     try {
56908       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >(arg1,arg2);
56909     } catch (std::out_of_range& e) {
56910       {
56911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56912       };
56913     } catch (std::exception& e) {
56914       {
56915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56916       };
56917     } catch (Dali::DaliException e) {
56918       {
56919         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56920       };
56921     } catch (...) {
56922       {
56923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56924       };
56925     }
56926   }
56927
56928   jresult = (void *)result;
56929   return jresult;
56930 }
56931
56932
56933 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_2(void * jarg1) {
56934   void * jresult ;
56935   std::pair< Dali::Radian,Dali::Radian > *arg1 = 0 ;
56936   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
56937
56938   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
56939   if (!arg1) {
56940     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< Dali::Radian,Dali::Radian > const & type is null", 0);
56941     return 0;
56942   }
56943   {
56944     try {
56945       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >((std::pair< Dali::Radian,Dali::Radian > const &)*arg1);
56946     } catch (std::out_of_range& e) {
56947       {
56948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56949       };
56950     } catch (std::exception& e) {
56951       {
56952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56953       };
56954     } catch (Dali::DaliException e) {
56955       {
56956         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56957       };
56958     } catch (...) {
56959       {
56960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56961       };
56962     }
56963   }
56964
56965   jresult = (void *)result;
56966   return jresult;
56967 }
56968
56969
56970 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_set(void * jarg1, void * jarg2) {
56971   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
56972   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
56973
56974   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
56975   arg2 = (Dali::Radian *)jarg2;
56976   if (arg1) (arg1)->first = *arg2;
56977 }
56978
56979
56980 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_get(void * jarg1) {
56981   void * jresult ;
56982   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
56983   Dali::Radian *result = 0 ;
56984
56985   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
56986   result = (Dali::Radian *)& ((arg1)->first);
56987   jresult = (void *)result;
56988   return jresult;
56989 }
56990
56991
56992 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_set(void * jarg1, void * jarg2) {
56993   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
56994   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
56995
56996   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
56997   arg2 = (Dali::Radian *)jarg2;
56998   if (arg1) (arg1)->second = *arg2;
56999 }
57000
57001
57002 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_get(void * jarg1) {
57003   void * jresult ;
57004   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
57005   Dali::Radian *result = 0 ;
57006
57007   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
57008   result = (Dali::Radian *)& ((arg1)->second);
57009   jresult = (void *)result;
57010   return jresult;
57011 }
57012
57013
57014 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleThresholdPair(void * jarg1) {
57015   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
57016
57017   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
57018   {
57019     try {
57020       delete arg1;
57021     } catch (std::out_of_range& e) {
57022       {
57023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57024       };
57025     } catch (std::exception& e) {
57026       {
57027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57028       };
57029     } catch (Dali::DaliException e) {
57030       {
57031         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57032       };
57033     } catch (...) {
57034       {
57035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57036       };
57037     }
57038   }
57039
57040 }
57041
57042
57043 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Empty(void * jarg1) {
57044   unsigned int jresult ;
57045   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57046   bool result;
57047
57048   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57049   {
57050     try {
57051       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);
57052     } catch (std::out_of_range& e) {
57053       {
57054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57055       };
57056     } catch (std::exception& e) {
57057       {
57058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57059       };
57060     } catch (Dali::DaliException e) {
57061       {
57062         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57063       };
57064     } catch (...) {
57065       {
57066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57067       };
57068     }
57069   }
57070
57071   jresult = result;
57072   return jresult;
57073 }
57074
57075
57076 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_GetConnectionCount(void * jarg1) {
57077   unsigned long jresult ;
57078   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57079   std::size_t result;
57080
57081   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57082   {
57083     try {
57084       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);
57085     } catch (std::out_of_range& e) {
57086       {
57087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57088       };
57089     } catch (std::exception& e) {
57090       {
57091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57092       };
57093     } catch (Dali::DaliException e) {
57094       {
57095         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57096       };
57097     } catch (...) {
57098       {
57099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57100       };
57101     }
57102   }
57103
57104   jresult = (unsigned long)result;
57105   return jresult;
57106 }
57107
57108
57109 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
57110   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57111   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
57112
57113   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57114   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
57115   {
57116     try {
57117       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
57118     } catch (std::out_of_range& e) {
57119       {
57120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57121       };
57122     } catch (std::exception& e) {
57123       {
57124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57125       };
57126     } catch (Dali::DaliException e) {
57127       {
57128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57129       };
57130     } catch (...) {
57131       {
57132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57133       };
57134     }
57135   }
57136
57137 }
57138
57139
57140 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
57141   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57142   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
57143
57144   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57145   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
57146   {
57147     try {
57148       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
57149     } catch (std::out_of_range& e) {
57150       {
57151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57152       };
57153     } catch (std::exception& e) {
57154       {
57155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57156       };
57157     } catch (Dali::DaliException e) {
57158       {
57159         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57160       };
57161     } catch (...) {
57162       {
57163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57164       };
57165     }
57166   }
57167
57168 }
57169
57170
57171 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
57172   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57173   Dali::Actor arg2 ;
57174   Dali::PanGesture *arg3 = 0 ;
57175   Dali::Actor *argp2 ;
57176
57177   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57178   argp2 = (Dali::Actor *)jarg2;
57179   if (!argp2) {
57180     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57181     return ;
57182   }
57183   arg2 = *argp2;
57184   arg3 = (Dali::PanGesture *)jarg3;
57185   if (!arg3) {
57186     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
57187     return ;
57188   }
57189   {
57190     try {
57191       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PanGesture const &)*arg3);
57192     } catch (std::out_of_range& e) {
57193       {
57194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57195       };
57196     } catch (std::exception& e) {
57197       {
57198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57199       };
57200     } catch (Dali::DaliException e) {
57201       {
57202         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57203       };
57204     } catch (...) {
57205       {
57206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57207       };
57208     }
57209   }
57210
57211 }
57212
57213
57214 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetectedSignal() {
57215   void * jresult ;
57216   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *result = 0 ;
57217
57218   {
57219     try {
57220       result = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) >();
57221     } catch (std::out_of_range& e) {
57222       {
57223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57224       };
57225     } catch (std::exception& e) {
57226       {
57227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57228       };
57229     } catch (Dali::DaliException e) {
57230       {
57231         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57232       };
57233     } catch (...) {
57234       {
57235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57236       };
57237     }
57238   }
57239
57240   jresult = (void *)result;
57241   return jresult;
57242 }
57243
57244
57245 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetectedSignal(void * jarg1) {
57246   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57247
57248   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57249   {
57250     try {
57251       delete arg1;
57252     } catch (std::out_of_range& e) {
57253       {
57254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57255       };
57256     } catch (std::exception& e) {
57257       {
57258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57259       };
57260     } catch (Dali::DaliException e) {
57261       {
57262         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57263       };
57264     } catch (...) {
57265       {
57266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57267       };
57268     }
57269   }
57270
57271 }
57272
57273
57274 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Empty(void * jarg1) {
57275   unsigned int jresult ;
57276   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57277   bool result;
57278
57279   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57280   {
57281     try {
57282       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);
57283     } catch (std::out_of_range& e) {
57284       {
57285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57286       };
57287     } catch (std::exception& e) {
57288       {
57289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57290       };
57291     } catch (Dali::DaliException e) {
57292       {
57293         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57294       };
57295     } catch (...) {
57296       {
57297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57298       };
57299     }
57300   }
57301
57302   jresult = result;
57303   return jresult;
57304 }
57305
57306
57307 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_GetConnectionCount(void * jarg1) {
57308   unsigned long jresult ;
57309   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57310   std::size_t result;
57311
57312   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57313   {
57314     try {
57315       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);
57316     } catch (std::out_of_range& e) {
57317       {
57318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57319       };
57320     } catch (std::exception& e) {
57321       {
57322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57323       };
57324     } catch (Dali::DaliException e) {
57325       {
57326         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57327       };
57328     } catch (...) {
57329       {
57330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57331       };
57332     }
57333   }
57334
57335   jresult = (unsigned long)result;
57336   return jresult;
57337 }
57338
57339
57340 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
57341   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57342   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
57343
57344   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57345   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
57346   {
57347     try {
57348       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
57349     } catch (std::out_of_range& e) {
57350       {
57351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57352       };
57353     } catch (std::exception& e) {
57354       {
57355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57356       };
57357     } catch (Dali::DaliException e) {
57358       {
57359         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57360       };
57361     } catch (...) {
57362       {
57363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57364       };
57365     }
57366   }
57367
57368 }
57369
57370
57371 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
57372   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57373   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
57374
57375   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57376   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
57377   {
57378     try {
57379       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
57380     } catch (std::out_of_range& e) {
57381       {
57382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57383       };
57384     } catch (std::exception& e) {
57385       {
57386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57387       };
57388     } catch (Dali::DaliException e) {
57389       {
57390         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57391       };
57392     } catch (...) {
57393       {
57394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57395       };
57396     }
57397   }
57398
57399 }
57400
57401
57402 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
57403   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57404   Dali::Actor arg2 ;
57405   Dali::PinchGesture *arg3 = 0 ;
57406   Dali::Actor *argp2 ;
57407
57408   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57409   argp2 = (Dali::Actor *)jarg2;
57410   if (!argp2) {
57411     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57412     return ;
57413   }
57414   arg2 = *argp2;
57415   arg3 = (Dali::PinchGesture *)jarg3;
57416   if (!arg3) {
57417     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
57418     return ;
57419   }
57420   {
57421     try {
57422       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PinchGesture const &)*arg3);
57423     } catch (std::out_of_range& e) {
57424       {
57425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57426       };
57427     } catch (std::exception& e) {
57428       {
57429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57430       };
57431     } catch (Dali::DaliException e) {
57432       {
57433         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57434       };
57435     } catch (...) {
57436       {
57437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57438       };
57439     }
57440   }
57441
57442 }
57443
57444
57445 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetectedSignal() {
57446   void * jresult ;
57447   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *result = 0 ;
57448
57449   {
57450     try {
57451       result = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) >();
57452     } catch (std::out_of_range& e) {
57453       {
57454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57455       };
57456     } catch (std::exception& e) {
57457       {
57458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57459       };
57460     } catch (Dali::DaliException e) {
57461       {
57462         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57463       };
57464     } catch (...) {
57465       {
57466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57467       };
57468     }
57469   }
57470
57471   jresult = (void *)result;
57472   return jresult;
57473 }
57474
57475
57476 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetectedSignal(void * jarg1) {
57477   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57478
57479   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57480   {
57481     try {
57482       delete arg1;
57483     } catch (std::out_of_range& e) {
57484       {
57485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57486       };
57487     } catch (std::exception& e) {
57488       {
57489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57490       };
57491     } catch (Dali::DaliException e) {
57492       {
57493         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57494       };
57495     } catch (...) {
57496       {
57497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57498       };
57499     }
57500   }
57501
57502 }
57503
57504
57505 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Empty(void * jarg1) {
57506   unsigned int jresult ;
57507   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57508   bool result;
57509
57510   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57511   {
57512     try {
57513       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);
57514     } catch (std::out_of_range& e) {
57515       {
57516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57517       };
57518     } catch (std::exception& e) {
57519       {
57520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57521       };
57522     } catch (Dali::DaliException e) {
57523       {
57524         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57525       };
57526     } catch (...) {
57527       {
57528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57529       };
57530     }
57531   }
57532
57533   jresult = result;
57534   return jresult;
57535 }
57536
57537
57538 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_GetConnectionCount(void * jarg1) {
57539   unsigned long jresult ;
57540   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57541   std::size_t result;
57542
57543   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57544   {
57545     try {
57546       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);
57547     } catch (std::out_of_range& e) {
57548       {
57549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57550       };
57551     } catch (std::exception& e) {
57552       {
57553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57554       };
57555     } catch (Dali::DaliException e) {
57556       {
57557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57558       };
57559     } catch (...) {
57560       {
57561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57562       };
57563     }
57564   }
57565
57566   jresult = (unsigned long)result;
57567   return jresult;
57568 }
57569
57570
57571 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
57572   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57573   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
57574
57575   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57576   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
57577   {
57578     try {
57579       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
57580     } catch (std::out_of_range& e) {
57581       {
57582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57583       };
57584     } catch (std::exception& e) {
57585       {
57586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57587       };
57588     } catch (Dali::DaliException e) {
57589       {
57590         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57591       };
57592     } catch (...) {
57593       {
57594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57595       };
57596     }
57597   }
57598
57599 }
57600
57601
57602 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
57603   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57604   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
57605
57606   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57607   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
57608   {
57609     try {
57610       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
57611     } catch (std::out_of_range& e) {
57612       {
57613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57614       };
57615     } catch (std::exception& e) {
57616       {
57617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57618       };
57619     } catch (Dali::DaliException e) {
57620       {
57621         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57622       };
57623     } catch (...) {
57624       {
57625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57626       };
57627     }
57628   }
57629
57630 }
57631
57632
57633 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
57634   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57635   Dali::Actor arg2 ;
57636   Dali::TapGesture *arg3 = 0 ;
57637   Dali::Actor *argp2 ;
57638
57639   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57640   argp2 = (Dali::Actor *)jarg2;
57641   if (!argp2) {
57642     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57643     return ;
57644   }
57645   arg2 = *argp2;
57646   arg3 = (Dali::TapGesture *)jarg3;
57647   if (!arg3) {
57648     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
57649     return ;
57650   }
57651   {
57652     try {
57653       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TapGesture const &)*arg3);
57654     } catch (std::out_of_range& e) {
57655       {
57656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57657       };
57658     } catch (std::exception& e) {
57659       {
57660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57661       };
57662     } catch (Dali::DaliException e) {
57663       {
57664         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57665       };
57666     } catch (...) {
57667       {
57668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57669       };
57670     }
57671   }
57672
57673 }
57674
57675
57676 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetectedSignal() {
57677   void * jresult ;
57678   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *result = 0 ;
57679
57680   {
57681     try {
57682       result = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) >();
57683     } catch (std::out_of_range& e) {
57684       {
57685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57686       };
57687     } catch (std::exception& e) {
57688       {
57689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57690       };
57691     } catch (Dali::DaliException e) {
57692       {
57693         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57694       };
57695     } catch (...) {
57696       {
57697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57698       };
57699     }
57700   }
57701
57702   jresult = (void *)result;
57703   return jresult;
57704 }
57705
57706
57707 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetectedSignal(void * jarg1) {
57708   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57709
57710   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57711   {
57712     try {
57713       delete arg1;
57714     } catch (std::out_of_range& e) {
57715       {
57716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57717       };
57718     } catch (std::exception& e) {
57719       {
57720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57721       };
57722     } catch (Dali::DaliException e) {
57723       {
57724         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57725       };
57726     } catch (...) {
57727       {
57728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57729       };
57730     }
57731   }
57732
57733 }
57734
57735 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Empty(void * jarg1) {
57736   unsigned int jresult ;
57737   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57738   bool result;
57739
57740   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57741   {
57742     try {
57743       result = (bool)Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Empty((Dali::Signal< void (Dali::ResourceImage) > const *)arg1);
57744     } catch (std::out_of_range& e) {
57745       {
57746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57747       };
57748     } catch (std::exception& e) {
57749       {
57750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57751       };
57752     } catch (Dali::DaliException e) {
57753       {
57754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57755       };
57756     } catch (...) {
57757       {
57758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57759       };
57760     }
57761   }
57762
57763   jresult = result;
57764   return jresult;
57765 }
57766
57767
57768 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ResourceImageSignal_GetConnectionCount(void * jarg1) {
57769   unsigned long jresult ;
57770   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57771   std::size_t result;
57772
57773   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57774   {
57775     try {
57776       result = Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::ResourceImage) > const *)arg1);
57777     } catch (std::out_of_range& e) {
57778       {
57779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57780       };
57781     } catch (std::exception& e) {
57782       {
57783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57784       };
57785     } catch (Dali::DaliException e) {
57786       {
57787         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57788       };
57789     } catch (...) {
57790       {
57791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57792       };
57793     }
57794   }
57795
57796   jresult = (unsigned long)result;
57797   return jresult;
57798 }
57799
57800
57801 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Connect(void * jarg1, void * jarg2) {
57802   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57803   void (*arg2)(Dali::ResourceImage) = (void (*)(Dali::ResourceImage)) 0 ;
57804
57805   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57806   arg2 = (void (*)(Dali::ResourceImage))jarg2;
57807   {
57808     try {
57809       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Connect(arg1,arg2);
57810     } catch (std::out_of_range& e) {
57811       {
57812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57813       };
57814     } catch (std::exception& e) {
57815       {
57816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57817       };
57818     } catch (Dali::DaliException e) {
57819       {
57820         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57821       };
57822     } catch (...) {
57823       {
57824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57825       };
57826     }
57827   }
57828
57829 }
57830
57831
57832 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Disconnect(void * jarg1, void * jarg2) {
57833   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57834   void (*arg2)(Dali::ResourceImage) = (void (*)(Dali::ResourceImage)) 0 ;
57835
57836   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57837   arg2 = (void (*)(Dali::ResourceImage))jarg2;
57838   {
57839     try {
57840       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Disconnect(arg1,arg2);
57841     } catch (std::out_of_range& e) {
57842       {
57843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57844       };
57845     } catch (std::exception& e) {
57846       {
57847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57848       };
57849     } catch (Dali::DaliException e) {
57850       {
57851         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57852       };
57853     } catch (...) {
57854       {
57855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57856       };
57857     }
57858   }
57859
57860 }
57861
57862
57863 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Emit(void * jarg1, void * jarg2) {
57864   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57865   Dali::ResourceImage arg2 ;
57866   Dali::ResourceImage *argp2 ;
57867
57868   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57869   argp2 = (Dali::ResourceImage *)jarg2;
57870   if (!argp2) {
57871     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ResourceImage", 0);
57872     return ;
57873   }
57874   arg2 = *argp2;
57875   {
57876     try {
57877       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Emit(arg1,arg2);
57878     } catch (std::out_of_range& e) {
57879       {
57880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57881       };
57882     } catch (std::exception& e) {
57883       {
57884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57885       };
57886     } catch (Dali::DaliException e) {
57887       {
57888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57889       };
57890     } catch (...) {
57891       {
57892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57893       };
57894     }
57895   }
57896
57897 }
57898
57899
57900 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImageSignal() {
57901   void * jresult ;
57902   Dali::Signal< void (Dali::ResourceImage) > *result = 0 ;
57903
57904   {
57905     try {
57906       result = (Dali::Signal< void (Dali::ResourceImage) > *)new Dali::Signal< void (Dali::ResourceImage) >();
57907     } catch (std::out_of_range& e) {
57908       {
57909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57910       };
57911     } catch (std::exception& e) {
57912       {
57913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57914       };
57915     } catch (Dali::DaliException e) {
57916       {
57917         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57918       };
57919     } catch (...) {
57920       {
57921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57922       };
57923     }
57924   }
57925
57926   jresult = (void *)result;
57927   return jresult;
57928 }
57929
57930
57931 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ResourceImageSignal(void * jarg1) {
57932   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57933
57934   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57935   {
57936     try {
57937       delete arg1;
57938     } catch (std::out_of_range& e) {
57939       {
57940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57941       };
57942     } catch (std::exception& e) {
57943       {
57944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57945       };
57946     } catch (Dali::DaliException e) {
57947       {
57948         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57949       };
57950     } catch (...) {
57951       {
57952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57953       };
57954     }
57955   }
57956
57957 }
57958
57959 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionChangedSignal_Empty(void * jarg1) {
57960   unsigned int jresult ;
57961   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
57962   bool result = false;
57963
57964   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
57965   {
57966     try {
57967       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);
57968     } catch (std::out_of_range& e) {
57969       {
57970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57971       };
57972     } catch (std::exception& e) {
57973       {
57974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57975       };
57976     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
57977   }
57978   jresult = result;
57979   return jresult;
57980 }
57981
57982 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_GetConnectionCount(void * jarg1) {
57983   unsigned long jresult ;
57984   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
57985   std::size_t result = 0;
57986
57987   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
57988   {
57989     try {
57990       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);
57991     } catch (std::out_of_range& e) {
57992       {
57993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57994       };
57995     } catch (std::exception& e) {
57996       {
57997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57998       };
57999     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58000   }
58001   jresult = (unsigned long)result;
58002   return jresult;
58003 }
58004
58005 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Connect(void * jarg1, void * jarg2) {
58006   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
58007   void (*arg2)(Dali::Actor, Dali::LayoutDirection::Type) = (void (*)(Dali::Actor, Dali::LayoutDirection::Type)) 0 ;
58008
58009   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
58010   arg2 = (void (*)(Dali::Actor, Dali::LayoutDirection::Type))jarg2;
58011   {
58012     try {
58013       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Connect(arg1,arg2);
58014     } catch (std::out_of_range& e) {
58015       {
58016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58017       };
58018     } catch (std::exception& e) {
58019       {
58020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58021       };
58022     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58023   }
58024 }
58025
58026 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Disconnect(void * jarg1, void * jarg2) {
58027   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
58028   void (*arg2)(Dali::Actor, Dali::LayoutDirection::Type) = (void (*)(Dali::Actor, Dali::LayoutDirection::Type)) 0 ;
58029
58030   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
58031   arg2 = (void (*)(Dali::Actor, Dali::LayoutDirection::Type))jarg2;
58032   {
58033     try {
58034       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Disconnect(arg1,arg2);
58035     } catch (std::out_of_range& e) {
58036       {
58037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58038       };
58039     } catch (std::exception& e) {
58040       {
58041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58042       };
58043     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58044   }
58045 }
58046
58047 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Emit(void * jarg1, void * jarg2, int jarg4) {
58048   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
58049   Dali::Actor arg2 ;
58050   //bool arg3 ;
58051   Dali::LayoutDirection::Type arg4 ;
58052   Dali::Actor *argp2 ;
58053
58054   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
58055   argp2 = (Dali::Actor *)jarg2;
58056   if (!argp2) {
58057     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
58058     return ;
58059   }
58060   arg2 = *argp2;
58061   //arg3 = jarg3 ? true : false;
58062   arg4 = (Dali::LayoutDirection::Type)jarg4;
58063   {
58064     try {
58065       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Emit(arg1,arg2,arg4);
58066     } catch (std::out_of_range& e) {
58067       {
58068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58069       };
58070     } catch (std::exception& e) {
58071       {
58072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58073       };
58074     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58075   }
58076 }
58077
58078 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewLayoutDirectionSignal() {
58079   void * jresult ;
58080   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *result = 0 ;
58081
58082   {
58083     try {
58084       result = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)new Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) >();
58085     } catch (std::out_of_range& e) {
58086       {
58087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58088       };
58089     } catch (std::exception& e) {
58090       {
58091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58092       };
58093     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58094   }
58095   jresult = (void *)result;
58096   return jresult;
58097 }
58098
58099 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewLayoutDirectionSignal(void * jarg1) {
58100   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
58101
58102   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
58103   {
58104     try {
58105       delete arg1;
58106     } catch (std::out_of_range& e) {
58107       {
58108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58109       };
58110     } catch (std::exception& e) {
58111       {
58112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58113       };
58114     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58115   }
58116 }
58117
58118 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Empty(void * jarg1) {
58119   unsigned int jresult ;
58120   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58121   bool result;
58122
58123   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58124   {
58125     try {
58126       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);
58127     } catch (std::out_of_range& e) {
58128       {
58129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58130       };
58131     } catch (std::exception& e) {
58132       {
58133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58134       };
58135     } catch (Dali::DaliException e) {
58136       {
58137         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58138       };
58139     } catch (...) {
58140       {
58141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58142       };
58143     }
58144   }
58145
58146   jresult = result;
58147   return jresult;
58148 }
58149
58150
58151 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_GetConnectionCount(void * jarg1) {
58152   unsigned long jresult ;
58153   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58154   std::size_t result;
58155
58156   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58157   {
58158     try {
58159       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);
58160     } catch (std::out_of_range& e) {
58161       {
58162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58163       };
58164     } catch (std::exception& e) {
58165       {
58166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58167       };
58168     } catch (Dali::DaliException e) {
58169       {
58170         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58171       };
58172     } catch (...) {
58173       {
58174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58175       };
58176     }
58177   }
58178
58179   jresult = (unsigned long)result;
58180   return jresult;
58181 }
58182
58183
58184 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Connect(void * jarg1, void * jarg2) {
58185   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58186   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
58187
58188   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58189   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
58190   {
58191     try {
58192       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Connect(arg1,arg2);
58193     } catch (std::out_of_range& e) {
58194       {
58195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58196       };
58197     } catch (std::exception& e) {
58198       {
58199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58200       };
58201     } catch (Dali::DaliException e) {
58202       {
58203         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58204       };
58205     } catch (...) {
58206       {
58207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58208       };
58209     }
58210   }
58211
58212 }
58213
58214
58215 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Disconnect(void * jarg1, void * jarg2) {
58216   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58217   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
58218
58219   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58220   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
58221   {
58222     try {
58223       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Disconnect(arg1,arg2);
58224     } catch (std::out_of_range& e) {
58225       {
58226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58227       };
58228     } catch (std::exception& e) {
58229       {
58230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58231       };
58232     } catch (Dali::DaliException e) {
58233       {
58234         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58235       };
58236     } catch (...) {
58237       {
58238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58239       };
58240     }
58241   }
58242
58243 }
58244
58245
58246 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, int jarg4) {
58247   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58248   Dali::Actor arg2 ;
58249   bool arg3 ;
58250   Dali::DevelActor::VisibilityChange::Type arg4 ;
58251   Dali::Actor *argp2 ;
58252
58253   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58254   argp2 = (Dali::Actor *)jarg2;
58255   if (!argp2) {
58256     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
58257     return ;
58258   }
58259   arg2 = *argp2;
58260   arg3 = jarg3 ? true : false;
58261   arg4 = (Dali::DevelActor::VisibilityChange::Type)jarg4;
58262   {
58263     try {
58264       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Emit(arg1,arg2,arg3,arg4);
58265     } catch (std::out_of_range& e) {
58266       {
58267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58268       };
58269     } catch (std::exception& e) {
58270       {
58271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58272       };
58273     } catch (Dali::DaliException e) {
58274       {
58275         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58276       };
58277     } catch (...) {
58278       {
58279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58280       };
58281     }
58282   }
58283
58284 }
58285
58286
58287 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewVisibilityChangedSignal() {
58288   void * jresult ;
58289   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *result = 0 ;
58290
58291   {
58292     try {
58293       result = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)new Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) >();
58294     } catch (std::out_of_range& e) {
58295       {
58296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58297       };
58298     } catch (std::exception& e) {
58299       {
58300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58301       };
58302     } catch (Dali::DaliException e) {
58303       {
58304         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58305       };
58306     } catch (...) {
58307       {
58308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58309       };
58310     }
58311   }
58312
58313   jresult = (void *)result;
58314   return jresult;
58315 }
58316
58317
58318 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewVisibilityChangedSignal(void * jarg1) {
58319   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58320
58321   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58322   {
58323     try {
58324       delete arg1;
58325     } catch (std::out_of_range& e) {
58326       {
58327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58328       };
58329     } catch (std::exception& e) {
58330       {
58331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58332       };
58333     } catch (Dali::DaliException e) {
58334       {
58335         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58336       };
58337     } catch (...) {
58338       {
58339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58340       };
58341     }
58342   }
58343
58344 }
58345
58346
58347 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_0() {
58348   void * jresult ;
58349   Dali::Timer *result = 0 ;
58350
58351   {
58352     try {
58353       result = (Dali::Timer *)new Dali::Timer();
58354     } catch (std::out_of_range& e) {
58355       {
58356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58357       };
58358     } catch (std::exception& e) {
58359       {
58360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58361       };
58362     } catch (Dali::DaliException e) {
58363       {
58364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58365       };
58366     } catch (...) {
58367       {
58368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58369       };
58370     }
58371   }
58372
58373   jresult = (void *)result;
58374   return jresult;
58375 }
58376
58377
58378 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_New(unsigned int jarg1) {
58379   void * jresult ;
58380   unsigned int arg1 ;
58381   Dali::Timer result;
58382
58383   arg1 = (unsigned int)jarg1;
58384   {
58385     try {
58386       result = Dali::Timer::New(arg1);
58387     } catch (std::out_of_range& e) {
58388       {
58389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58390       };
58391     } catch (std::exception& e) {
58392       {
58393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58394       };
58395     } catch (Dali::DaliException e) {
58396       {
58397         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58398       };
58399     } catch (...) {
58400       {
58401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58402       };
58403     }
58404   }
58405
58406   jresult = new Dali::Timer((const Dali::Timer &)result);
58407   return jresult;
58408 }
58409
58410
58411 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_1(void * jarg1) {
58412   void * jresult ;
58413   Dali::Timer *arg1 = 0 ;
58414   Dali::Timer *result = 0 ;
58415
58416   arg1 = (Dali::Timer *)jarg1;
58417   if (!arg1) {
58418     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
58419     return 0;
58420   }
58421   {
58422     try {
58423       result = (Dali::Timer *)new Dali::Timer((Dali::Timer const &)*arg1);
58424     } catch (std::out_of_range& e) {
58425       {
58426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58427       };
58428     } catch (std::exception& e) {
58429       {
58430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58431       };
58432     } catch (Dali::DaliException e) {
58433       {
58434         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58435       };
58436     } catch (...) {
58437       {
58438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58439       };
58440     }
58441   }
58442
58443   jresult = (void *)result;
58444   return jresult;
58445 }
58446
58447
58448 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_Assign(void * jarg1, void * jarg2) {
58449   void * jresult ;
58450   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58451   Dali::Timer *arg2 = 0 ;
58452   Dali::Timer *result = 0 ;
58453
58454   arg1 = (Dali::Timer *)jarg1;
58455   arg2 = (Dali::Timer *)jarg2;
58456   if (!arg2) {
58457     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
58458     return 0;
58459   }
58460   {
58461     try {
58462       result = (Dali::Timer *) &(arg1)->operator =((Dali::Timer const &)*arg2);
58463     } catch (std::out_of_range& e) {
58464       {
58465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58466       };
58467     } catch (std::exception& e) {
58468       {
58469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58470       };
58471     } catch (Dali::DaliException e) {
58472       {
58473         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58474       };
58475     } catch (...) {
58476       {
58477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58478       };
58479     }
58480   }
58481
58482   jresult = (void *)result;
58483   return jresult;
58484 }
58485
58486
58487 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Timer(void * jarg1) {
58488   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58489
58490   arg1 = (Dali::Timer *)jarg1;
58491   {
58492     try {
58493       delete arg1;
58494     } catch (std::out_of_range& e) {
58495       {
58496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58497       };
58498     } catch (std::exception& e) {
58499       {
58500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58501       };
58502     } catch (Dali::DaliException e) {
58503       {
58504         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58505       };
58506     } catch (...) {
58507       {
58508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58509       };
58510     }
58511   }
58512
58513 }
58514
58515
58516 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_DownCast(void * jarg1) {
58517   void * jresult ;
58518   Dali::BaseHandle arg1 ;
58519   Dali::BaseHandle *argp1 ;
58520   Dali::Timer result;
58521
58522   argp1 = (Dali::BaseHandle *)jarg1;
58523   if (!argp1) {
58524     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
58525     return 0;
58526   }
58527   arg1 = *argp1;
58528   {
58529     try {
58530       result = Dali::Timer::DownCast(arg1);
58531     } catch (std::out_of_range& e) {
58532       {
58533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58534       };
58535     } catch (std::exception& e) {
58536       {
58537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58538       };
58539     } catch (Dali::DaliException e) {
58540       {
58541         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58542       };
58543     } catch (...) {
58544       {
58545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58546       };
58547     }
58548   }
58549
58550   jresult = new Dali::Timer((const Dali::Timer &)result);
58551   return jresult;
58552 }
58553
58554
58555 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Start(void * jarg1) {
58556   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58557
58558   arg1 = (Dali::Timer *)jarg1;
58559   {
58560     try {
58561       (arg1)->Start();
58562     } catch (std::out_of_range& e) {
58563       {
58564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58565       };
58566     } catch (std::exception& e) {
58567       {
58568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58569       };
58570     } catch (Dali::DaliException e) {
58571       {
58572         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58573       };
58574     } catch (...) {
58575       {
58576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58577       };
58578     }
58579   }
58580
58581 }
58582
58583
58584 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Stop(void * jarg1) {
58585   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58586
58587   arg1 = (Dali::Timer *)jarg1;
58588   {
58589     try {
58590       (arg1)->Stop();
58591     } catch (std::out_of_range& e) {
58592       {
58593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58594       };
58595     } catch (std::exception& e) {
58596       {
58597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58598       };
58599     } catch (Dali::DaliException e) {
58600       {
58601         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58602       };
58603     } catch (...) {
58604       {
58605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58606       };
58607     }
58608   }
58609
58610 }
58611
58612
58613 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_SetInterval(void * jarg1, unsigned int jarg2) {
58614   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58615   unsigned int arg2 ;
58616
58617   arg1 = (Dali::Timer *)jarg1;
58618   arg2 = (unsigned int)jarg2;
58619   {
58620     try {
58621       (arg1)->SetInterval(arg2);
58622     } catch (std::out_of_range& e) {
58623       {
58624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58625       };
58626     } catch (std::exception& e) {
58627       {
58628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58629       };
58630     } catch (Dali::DaliException e) {
58631       {
58632         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58633       };
58634     } catch (...) {
58635       {
58636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58637       };
58638     }
58639   }
58640
58641 }
58642
58643
58644 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_GetInterval(void * jarg1) {
58645   unsigned int jresult ;
58646   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58647   unsigned int result;
58648
58649   arg1 = (Dali::Timer *)jarg1;
58650   {
58651     try {
58652       result = (unsigned int)((Dali::Timer const *)arg1)->GetInterval();
58653     } catch (std::out_of_range& e) {
58654       {
58655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58656       };
58657     } catch (std::exception& e) {
58658       {
58659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58660       };
58661     } catch (Dali::DaliException e) {
58662       {
58663         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58664       };
58665     } catch (...) {
58666       {
58667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58668       };
58669     }
58670   }
58671
58672   jresult = result;
58673   return jresult;
58674 }
58675
58676
58677 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_IsRunning(void * jarg1) {
58678   unsigned int jresult ;
58679   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58680   bool result;
58681
58682   arg1 = (Dali::Timer *)jarg1;
58683   {
58684     try {
58685       result = (bool)((Dali::Timer const *)arg1)->IsRunning();
58686     } catch (std::out_of_range& e) {
58687       {
58688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58689       };
58690     } catch (std::exception& e) {
58691       {
58692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58693       };
58694     } catch (Dali::DaliException e) {
58695       {
58696         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58697       };
58698     } catch (...) {
58699       {
58700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58701       };
58702     }
58703   }
58704
58705   jresult = result;
58706   return jresult;
58707 }
58708
58709
58710 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_TickSignal(void * jarg1) {
58711   void * jresult ;
58712   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58713   Dali::Timer::TimerSignalType *result = 0 ;
58714
58715   arg1 = (Dali::Timer *)jarg1;
58716   {
58717     try {
58718       result = (Dali::Timer::TimerSignalType *) &(arg1)->TickSignal();
58719     } catch (std::out_of_range& e) {
58720       {
58721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58722       };
58723     } catch (std::exception& e) {
58724       {
58725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58726       };
58727     } catch (Dali::DaliException e) {
58728       {
58729         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58730       };
58731     } catch (...) {
58732       {
58733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58734       };
58735     }
58736   }
58737
58738   jresult = (void *)result;
58739   return jresult;
58740 }
58741
58742
58743 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DragAndDropDetector() {
58744   void * jresult ;
58745   Dali::DragAndDropDetector *result = 0 ;
58746
58747   {
58748     try {
58749       result = (Dali::DragAndDropDetector *)new Dali::DragAndDropDetector();
58750     } catch (std::out_of_range& e) {
58751       {
58752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58753       };
58754     } catch (std::exception& e) {
58755       {
58756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58757       };
58758     } catch (Dali::DaliException e) {
58759       {
58760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58761       };
58762     } catch (...) {
58763       {
58764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58765       };
58766     }
58767   }
58768
58769   jresult = (void *)result;
58770   return jresult;
58771 }
58772
58773
58774 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DragAndDropDetector(void * jarg1) {
58775   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
58776
58777   arg1 = (Dali::DragAndDropDetector *)jarg1;
58778   {
58779     try {
58780       delete arg1;
58781     } catch (std::out_of_range& e) {
58782       {
58783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58784       };
58785     } catch (std::exception& e) {
58786       {
58787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58788       };
58789     } catch (Dali::DaliException e) {
58790       {
58791         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58792       };
58793     } catch (...) {
58794       {
58795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58796       };
58797     }
58798   }
58799
58800 }
58801
58802
58803 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_GetContent(void * jarg1) {
58804   char * jresult ;
58805   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
58806   std::string *result = 0 ;
58807
58808   arg1 = (Dali::DragAndDropDetector *)jarg1;
58809   {
58810     try {
58811       result = (std::string *) &((Dali::DragAndDropDetector const *)arg1)->GetContent();
58812     } catch (std::out_of_range& e) {
58813       {
58814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58815       };
58816     } catch (std::exception& e) {
58817       {
58818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58819       };
58820     } catch (Dali::DaliException e) {
58821       {
58822         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58823       };
58824     } catch (...) {
58825       {
58826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58827       };
58828     }
58829   }
58830
58831   jresult = SWIG_csharp_string_callback(result->c_str());
58832   return jresult;
58833 }
58834
58835
58836 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_GetCurrentScreenPosition(void * jarg1) {
58837   void * jresult ;
58838   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
58839   Dali::Vector2 result;
58840
58841   arg1 = (Dali::DragAndDropDetector *)jarg1;
58842   {
58843     try {
58844       result = ((Dali::DragAndDropDetector const *)arg1)->GetCurrentScreenPosition();
58845     } catch (std::out_of_range& e) {
58846       {
58847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58848       };
58849     } catch (std::exception& e) {
58850       {
58851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58852       };
58853     } catch (Dali::DaliException e) {
58854       {
58855         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58856       };
58857     } catch (...) {
58858       {
58859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58860       };
58861     }
58862   }
58863
58864   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
58865   return jresult;
58866 }
58867
58868
58869 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_EnteredSignal(void * jarg1) {
58870   void * jresult ;
58871   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
58872   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
58873
58874   arg1 = (Dali::DragAndDropDetector *)jarg1;
58875   {
58876     try {
58877       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->EnteredSignal();
58878     } catch (std::out_of_range& e) {
58879       {
58880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58881       };
58882     } catch (std::exception& e) {
58883       {
58884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58885       };
58886     } catch (Dali::DaliException e) {
58887       {
58888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58889       };
58890     } catch (...) {
58891       {
58892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58893       };
58894     }
58895   }
58896
58897   jresult = (void *)result;
58898   return jresult;
58899 }
58900
58901
58902 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_ExitedSignal(void * jarg1) {
58903   void * jresult ;
58904   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
58905   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
58906
58907   arg1 = (Dali::DragAndDropDetector *)jarg1;
58908   {
58909     try {
58910       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->ExitedSignal();
58911     } catch (std::out_of_range& e) {
58912       {
58913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58914       };
58915     } catch (std::exception& e) {
58916       {
58917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58918       };
58919     } catch (Dali::DaliException e) {
58920       {
58921         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58922       };
58923     } catch (...) {
58924       {
58925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58926       };
58927     }
58928   }
58929
58930   jresult = (void *)result;
58931   return jresult;
58932 }
58933
58934
58935 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_MovedSignal(void * jarg1) {
58936   void * jresult ;
58937   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
58938   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
58939
58940   arg1 = (Dali::DragAndDropDetector *)jarg1;
58941   {
58942     try {
58943       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->MovedSignal();
58944     } catch (std::out_of_range& e) {
58945       {
58946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58947       };
58948     } catch (std::exception& e) {
58949       {
58950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58951       };
58952     } catch (Dali::DaliException e) {
58953       {
58954         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58955       };
58956     } catch (...) {
58957       {
58958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58959       };
58960     }
58961   }
58962
58963   jresult = (void *)result;
58964   return jresult;
58965 }
58966
58967
58968 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_DroppedSignal(void * jarg1) {
58969   void * jresult ;
58970   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
58971   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
58972
58973   arg1 = (Dali::DragAndDropDetector *)jarg1;
58974   {
58975     try {
58976       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->DroppedSignal();
58977     } catch (std::out_of_range& e) {
58978       {
58979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58980       };
58981     } catch (std::exception& e) {
58982       {
58983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58984       };
58985     } catch (Dali::DaliException e) {
58986       {
58987         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58988       };
58989     } catch (...) {
58990       {
58991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58992       };
58993     }
58994   }
58995
58996   jresult = (void *)result;
58997   return jresult;
58998 }
58999
59000 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Empty(void * jarg1) {
59001   unsigned int jresult ;
59002   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
59003   bool result;
59004
59005   arg1 = (Dali::Signal< bool () > *)jarg1;
59006   {
59007     try {
59008       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Empty((Dali::Signal< bool () > const *)arg1);
59009     } catch (std::out_of_range& e) {
59010       {
59011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59012       };
59013     } catch (std::exception& e) {
59014       {
59015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59016       };
59017     } catch (Dali::DaliException e) {
59018       {
59019         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59020       };
59021     } catch (...) {
59022       {
59023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59024       };
59025     }
59026   }
59027
59028   jresult = result;
59029   return jresult;
59030 }
59031
59032
59033 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TimerSignalType_GetConnectionCount(void * jarg1) {
59034   unsigned long jresult ;
59035   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
59036   std::size_t result;
59037
59038   arg1 = (Dali::Signal< bool () > *)jarg1;
59039   {
59040     try {
59041       result = Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount((Dali::Signal< bool () > const *)arg1);
59042     } catch (std::out_of_range& e) {
59043       {
59044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59045       };
59046     } catch (std::exception& e) {
59047       {
59048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59049       };
59050     } catch (Dali::DaliException e) {
59051       {
59052         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59053       };
59054     } catch (...) {
59055       {
59056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59057       };
59058     }
59059   }
59060
59061   jresult = (unsigned long)result;
59062   return jresult;
59063 }
59064
59065
59066 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Connect(void * jarg1, void * jarg2) {
59067   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
59068   bool (*arg2)() = (bool (*)()) 0 ;
59069
59070   arg1 = (Dali::Signal< bool () > *)jarg1;
59071   arg2 = (bool (*)())jarg2;
59072   {
59073     try {
59074       Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(arg1,arg2);
59075     } catch (std::out_of_range& e) {
59076       {
59077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59078       };
59079     } catch (std::exception& e) {
59080       {
59081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59082       };
59083     } catch (Dali::DaliException e) {
59084       {
59085         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59086       };
59087     } catch (...) {
59088       {
59089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59090       };
59091     }
59092   }
59093
59094 }
59095
59096
59097 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Disconnect(void * jarg1, void * jarg2) {
59098   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
59099   bool (*arg2)() = (bool (*)()) 0 ;
59100
59101   arg1 = (Dali::Signal< bool () > *)jarg1;
59102   arg2 = (bool (*)())jarg2;
59103   {
59104     try {
59105       Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(arg1,arg2);
59106     } catch (std::out_of_range& e) {
59107       {
59108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59109       };
59110     } catch (std::exception& e) {
59111       {
59112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59113       };
59114     } catch (Dali::DaliException e) {
59115       {
59116         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59117       };
59118     } catch (...) {
59119       {
59120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59121       };
59122     }
59123   }
59124
59125 }
59126
59127
59128 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Emit(void * jarg1) {
59129   unsigned int jresult ;
59130   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
59131   bool result;
59132
59133   arg1 = (Dali::Signal< bool () > *)jarg1;
59134   {
59135     try {
59136       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(arg1);
59137     } catch (std::out_of_range& e) {
59138       {
59139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59140       };
59141     } catch (std::exception& e) {
59142       {
59143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59144       };
59145     } catch (Dali::DaliException e) {
59146       {
59147         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59148       };
59149     } catch (...) {
59150       {
59151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59152       };
59153     }
59154   }
59155
59156   jresult = result;
59157   return jresult;
59158 }
59159
59160
59161 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimerSignalType() {
59162   void * jresult ;
59163   Dali::Signal< bool () > *result = 0 ;
59164
59165   {
59166     try {
59167       result = (Dali::Signal< bool () > *)new Dali::Signal< bool () >();
59168     } catch (std::out_of_range& e) {
59169       {
59170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59171       };
59172     } catch (std::exception& e) {
59173       {
59174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59175       };
59176     } catch (Dali::DaliException e) {
59177       {
59178         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59179       };
59180     } catch (...) {
59181       {
59182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59183       };
59184     }
59185   }
59186
59187   jresult = (void *)result;
59188   return jresult;
59189 }
59190
59191
59192 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimerSignalType(void * jarg1) {
59193   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
59194
59195   arg1 = (Dali::Signal< bool () > *)jarg1;
59196   {
59197     try {
59198       delete arg1;
59199     } catch (std::out_of_range& e) {
59200       {
59201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59202       };
59203     } catch (std::exception& e) {
59204       {
59205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59206       };
59207     } catch (Dali::DaliException e) {
59208       {
59209         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59210       };
59211     } catch (...) {
59212       {
59213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59214       };
59215     }
59216   }
59217
59218 }
59219
59220
59221 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_TYPE_get() {
59222   int jresult ;
59223   int result;
59224
59225   {
59226     try {
59227       result = (int)Dali::Toolkit::Visual::Property::TYPE;
59228     } catch (std::out_of_range& e) {
59229       {
59230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59231       };
59232     } catch (std::exception& e) {
59233       {
59234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59235       };
59236     } catch (Dali::DaliException e) {
59237       {
59238         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59239       };
59240     } catch (...) {
59241       {
59242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59243       };
59244     }
59245   }
59246
59247   jresult = (int)result;
59248   return jresult;
59249 }
59250
59251
59252 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_SHADER_get() {
59253   int jresult ;
59254   int result;
59255
59256   {
59257     try {
59258       result = (int)Dali::Toolkit::Visual::Property::SHADER;
59259     } catch (std::out_of_range& e) {
59260       {
59261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59262       };
59263     } catch (std::exception& e) {
59264       {
59265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59266       };
59267     } catch (Dali::DaliException e) {
59268       {
59269         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59270       };
59271     } catch (...) {
59272       {
59273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59274       };
59275     }
59276   }
59277
59278   jresult = (int)result;
59279   return jresult;
59280 }
59281
59282
59283 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_VERTEX_get() {
59284   int jresult ;
59285   int result;
59286
59287   {
59288     try {
59289       result = (int)Dali::Toolkit::Visual::Shader::Property::VERTEX_SHADER;
59290     } catch (std::out_of_range& e) {
59291       {
59292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59293       };
59294     } catch (std::exception& e) {
59295       {
59296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59297       };
59298     } catch (Dali::DaliException e) {
59299       {
59300         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59301       };
59302     } catch (...) {
59303       {
59304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59305       };
59306     }
59307   }
59308
59309   jresult = (int)result;
59310   return jresult;
59311 }
59312
59313
59314 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_FRAGMENT_get() {
59315   int jresult ;
59316   int result;
59317
59318   {
59319     try {
59320       result = (int)Dali::Toolkit::Visual::Shader::Property::FRAGMENT_SHADER;
59321     } catch (std::out_of_range& e) {
59322       {
59323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59324       };
59325     } catch (std::exception& e) {
59326       {
59327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59328       };
59329     } catch (Dali::DaliException e) {
59330       {
59331         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59332       };
59333     } catch (...) {
59334       {
59335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59336       };
59337     }
59338   }
59339
59340   jresult = (int)result;
59341   return jresult;
59342 }
59343
59344
59345 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_X_get() {
59346   int jresult ;
59347   int result;
59348
59349   {
59350     try {
59351       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_X;
59352     } catch (std::out_of_range& e) {
59353       {
59354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59355       };
59356     } catch (std::exception& e) {
59357       {
59358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59359       };
59360     } catch (Dali::DaliException e) {
59361       {
59362         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59363       };
59364     } catch (...) {
59365       {
59366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59367       };
59368     }
59369   }
59370
59371   jresult = (int)result;
59372   return jresult;
59373 }
59374
59375
59376 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_Y_get() {
59377   int jresult ;
59378   int result;
59379
59380   {
59381     try {
59382       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_Y;
59383     } catch (std::out_of_range& e) {
59384       {
59385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59386       };
59387     } catch (std::exception& e) {
59388       {
59389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59390       };
59391     } catch (Dali::DaliException e) {
59392       {
59393         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59394       };
59395     } catch (...) {
59396       {
59397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59398       };
59399     }
59400   }
59401
59402   jresult = (int)result;
59403   return jresult;
59404 }
59405
59406
59407 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_HINTS_get() {
59408   int jresult ;
59409   int result;
59410
59411   {
59412     try {
59413       result = (int)Dali::Toolkit::Visual::Shader::Property::HINTS;
59414     } catch (std::out_of_range& e) {
59415       {
59416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59417       };
59418     } catch (std::exception& e) {
59419       {
59420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59421       };
59422     } catch (Dali::DaliException e) {
59423       {
59424         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59425       };
59426     } catch (...) {
59427       {
59428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59429       };
59430     }
59431   }
59432
59433   jresult = (int)result;
59434   return jresult;
59435 }
59436
59437
59438 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_COLOR_get() {
59439   int jresult ;
59440   int result;
59441
59442   {
59443     try {
59444       result = (int)Dali::Toolkit::BorderVisual::Property::COLOR;
59445     } catch (std::out_of_range& e) {
59446       {
59447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59448       };
59449     } catch (std::exception& e) {
59450       {
59451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59452       };
59453     } catch (Dali::DaliException e) {
59454       {
59455         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59456       };
59457     } catch (...) {
59458       {
59459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59460       };
59461     }
59462   }
59463
59464   jresult = (int)result;
59465   return jresult;
59466 }
59467
59468
59469 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_SIZE_get() {
59470   int jresult ;
59471   int result;
59472
59473   {
59474     try {
59475       result = (int)Dali::Toolkit::BorderVisual::Property::SIZE;
59476     } catch (std::out_of_range& e) {
59477       {
59478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59479       };
59480     } catch (std::exception& e) {
59481       {
59482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59483       };
59484     } catch (Dali::DaliException e) {
59485       {
59486         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59487       };
59488     } catch (...) {
59489       {
59490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59491       };
59492     }
59493   }
59494
59495   jresult = (int)result;
59496   return jresult;
59497 }
59498
59499
59500 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_ANTI_ALIASING_get() {
59501   int jresult ;
59502   int result;
59503
59504   {
59505     try {
59506       result = (int)Dali::Toolkit::BorderVisual::Property::ANTI_ALIASING;
59507     } catch (std::out_of_range& e) {
59508       {
59509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59510       };
59511     } catch (std::exception& e) {
59512       {
59513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59514       };
59515     } catch (Dali::DaliException e) {
59516       {
59517         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59518       };
59519     } catch (...) {
59520       {
59521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59522       };
59523     }
59524   }
59525
59526   jresult = (int)result;
59527   return jresult;
59528 }
59529
59530
59531 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_COLOR_VISUAL_MIX_COLOR_get() {
59532   int jresult ;
59533   int result;
59534
59535   {
59536     try {
59537       result = (int)Dali::Toolkit::ColorVisual::Property::MIX_COLOR;
59538     } catch (std::out_of_range& e) {
59539       {
59540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59541       };
59542     } catch (std::exception& e) {
59543       {
59544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59545       };
59546     } catch (Dali::DaliException e) {
59547       {
59548         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59549       };
59550     } catch (...) {
59551       {
59552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59553       };
59554     }
59555   }
59556
59557   jresult = (int)result;
59558   return jresult;
59559 }
59560
59561
59562 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_START_POSITION_get() {
59563   int jresult ;
59564   int result;
59565
59566   {
59567     try {
59568       result = (int)Dali::Toolkit::GradientVisual::Property::START_POSITION;
59569     } catch (std::out_of_range& e) {
59570       {
59571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59572       };
59573     } catch (std::exception& e) {
59574       {
59575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59576       };
59577     } catch (Dali::DaliException e) {
59578       {
59579         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59580       };
59581     } catch (...) {
59582       {
59583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59584       };
59585     }
59586   }
59587
59588   jresult = (int)result;
59589   return jresult;
59590 }
59591
59592
59593 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_END_POSITION_get() {
59594   int jresult ;
59595   int result;
59596
59597   {
59598     try {
59599       result = (int)Dali::Toolkit::GradientVisual::Property::END_POSITION;
59600     } catch (std::out_of_range& e) {
59601       {
59602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59603       };
59604     } catch (std::exception& e) {
59605       {
59606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59607       };
59608     } catch (Dali::DaliException e) {
59609       {
59610         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59611       };
59612     } catch (...) {
59613       {
59614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59615       };
59616     }
59617   }
59618
59619   jresult = (int)result;
59620   return jresult;
59621 }
59622
59623
59624 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_CENTER_get() {
59625   int jresult ;
59626   int result;
59627
59628   {
59629     try {
59630       result = (int)Dali::Toolkit::GradientVisual::Property::CENTER;
59631     } catch (std::out_of_range& e) {
59632       {
59633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59634       };
59635     } catch (std::exception& e) {
59636       {
59637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59638       };
59639     } catch (Dali::DaliException e) {
59640       {
59641         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59642       };
59643     } catch (...) {
59644       {
59645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59646       };
59647     }
59648   }
59649
59650   jresult = (int)result;
59651   return jresult;
59652 }
59653
59654
59655 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_RADIUS_get() {
59656   int jresult ;
59657   int result;
59658
59659   {
59660     try {
59661       result = (int)Dali::Toolkit::GradientVisual::Property::RADIUS;
59662     } catch (std::out_of_range& e) {
59663       {
59664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59665       };
59666     } catch (std::exception& e) {
59667       {
59668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59669       };
59670     } catch (Dali::DaliException e) {
59671       {
59672         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59673       };
59674     } catch (...) {
59675       {
59676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59677       };
59678     }
59679   }
59680
59681   jresult = (int)result;
59682   return jresult;
59683 }
59684
59685
59686 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_OFFSET_get() {
59687   int jresult ;
59688   int result;
59689
59690   {
59691     try {
59692       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_OFFSET;
59693     } catch (std::out_of_range& e) {
59694       {
59695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59696       };
59697     } catch (std::exception& e) {
59698       {
59699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59700       };
59701     } catch (Dali::DaliException e) {
59702       {
59703         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59704       };
59705     } catch (...) {
59706       {
59707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59708       };
59709     }
59710   }
59711
59712   jresult = (int)result;
59713   return jresult;
59714 }
59715
59716
59717 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_COLOR_get() {
59718   int jresult ;
59719   int result;
59720
59721   {
59722     try {
59723       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_COLOR;
59724     } catch (std::out_of_range& e) {
59725       {
59726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59727       };
59728     } catch (std::exception& e) {
59729       {
59730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59731       };
59732     } catch (Dali::DaliException e) {
59733       {
59734         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59735       };
59736     } catch (...) {
59737       {
59738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59739       };
59740     }
59741   }
59742
59743   jresult = (int)result;
59744   return jresult;
59745 }
59746
59747
59748 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_UNITS_get() {
59749   int jresult ;
59750   int result;
59751
59752   {
59753     try {
59754       result = (int)Dali::Toolkit::GradientVisual::Property::UNITS;
59755     } catch (std::out_of_range& e) {
59756       {
59757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59758       };
59759     } catch (std::exception& e) {
59760       {
59761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59762       };
59763     } catch (Dali::DaliException e) {
59764       {
59765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59766       };
59767     } catch (...) {
59768       {
59769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59770       };
59771     }
59772   }
59773
59774   jresult = (int)result;
59775   return jresult;
59776 }
59777
59778
59779 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_SPREAD_METHOD_get() {
59780   int jresult ;
59781   int result;
59782
59783   {
59784     try {
59785       result = (int)Dali::Toolkit::GradientVisual::Property::SPREAD_METHOD;
59786     } catch (std::out_of_range& e) {
59787       {
59788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59789       };
59790     } catch (std::exception& e) {
59791       {
59792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59793       };
59794     } catch (Dali::DaliException e) {
59795       {
59796         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59797       };
59798     } catch (...) {
59799       {
59800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59801       };
59802     }
59803   }
59804
59805   jresult = (int)result;
59806   return jresult;
59807 }
59808
59809
59810 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_URL_get() {
59811   int jresult ;
59812   int result;
59813
59814   {
59815     try {
59816       result = (int)Dali::Toolkit::ImageVisual::Property::URL;
59817     } catch (std::out_of_range& e) {
59818       {
59819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59820       };
59821     } catch (std::exception& e) {
59822       {
59823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59824       };
59825     } catch (Dali::DaliException e) {
59826       {
59827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59828       };
59829     } catch (...) {
59830       {
59831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59832       };
59833     }
59834   }
59835
59836   jresult = (int)result;
59837   return jresult;
59838 }
59839
59840 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ALPHA_MASK_URL_get() {
59841   int jresult ;
59842   int result;
59843
59844   {
59845     try {
59846       result = (int)Dali::Toolkit::ImageVisual::Property::ALPHA_MASK_URL;
59847     } catch (std::out_of_range& e) {
59848       {
59849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59850       };
59851     } catch (std::exception& e) {
59852       {
59853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59854       };
59855     } catch (Dali::DaliException e) {
59856       {
59857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59858       };
59859     } catch (...) {
59860       {
59861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59862       };
59863     }
59864   }
59865
59866   jresult = (int)result;
59867   return jresult;
59868 }
59869
59870
59871 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BATCH_SIZE_get() {
59872   int jresult ;
59873   int result;
59874   {
59875     try
59876     {
59877       result = (int)Dali::Toolkit::ImageVisual::Property::BATCH_SIZE;
59878     } catch (std::out_of_range& e) {
59879       {
59880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59881       };
59882     } catch (std::exception& e) {
59883       {
59884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59885       };
59886     } catch (Dali::DaliException e) {
59887       {
59888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59889       };
59890     } catch (...) {
59891       {
59892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59893       };
59894     }
59895   }
59896
59897   jresult = (int)result;
59898   return jresult;
59899 }
59900
59901 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CACHE_SIZE_get() {
59902   int jresult ;
59903   int result;
59904   {
59905     try
59906     {
59907       result = (int)Dali::Toolkit::ImageVisual::Property::CACHE_SIZE;
59908     } catch (std::out_of_range& e) {
59909       {
59910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59911       };
59912     } catch (std::exception& e) {
59913       {
59914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59915       };
59916     } catch (Dali::DaliException e) {
59917       {
59918         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59919       };
59920     } catch (...) {
59921       {
59922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59923       };
59924     }
59925   }
59926
59927   jresult = (int)result;
59928   return jresult;
59929 }
59930
59931 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FRAME_DELAY_get() {
59932   int jresult ;
59933   int result;
59934   {
59935     try
59936     {
59937       result = (int)Dali::Toolkit::ImageVisual::Property::FRAME_DELAY;
59938     } catch (std::out_of_range& e) {
59939       {
59940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59941       };
59942     } catch (std::exception& e) {
59943       {
59944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59945       };
59946     } catch (Dali::DaliException e) {
59947       {
59948         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59949       };
59950     } catch (...) {
59951       {
59952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59953       };
59954     }
59955   }
59956
59957   jresult = (int)result;
59958   return jresult;
59959 }
59960
59961 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_LOOP_COUNT_get() {
59962   return (int)Dali::Toolkit::DevelImageVisual::Property::LOOP_COUNT;
59963 }
59964
59965 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_MASK_CONTENT_SCALE_get() {
59966   int jresult ;
59967   int result;
59968   {
59969     try
59970     {
59971       result = (int)Dali::Toolkit::ImageVisual::Property::MASK_CONTENT_SCALE;
59972     } catch (std::out_of_range& e) {
59973       {
59974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59975       };
59976     } catch (std::exception& e) {
59977       {
59978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59979       };
59980     } catch (Dali::DaliException e) {
59981       {
59982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59983       };
59984     } catch (...) {
59985       {
59986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59987       };
59988     }
59989   }
59990
59991   jresult = (int)result;
59992   return jresult;
59993 }
59994
59995 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CROP_TO_MASK_get() {
59996   int jresult ;
59997   int result;
59998   {
59999     try
60000     {
60001       result = (int)Dali::Toolkit::ImageVisual::Property::CROP_TO_MASK;
60002     } catch (std::out_of_range& e) {
60003       {
60004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60005       };
60006     } catch (std::exception& e) {
60007       {
60008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60009       };
60010     } catch (Dali::DaliException e) {
60011       {
60012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60013       };
60014     } catch (...) {
60015       {
60016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60017       };
60018     }
60019   }
60020
60021   jresult = (int)result;
60022   return jresult;
60023 }
60024
60025 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FITTING_MODE_get() {
60026   int jresult ;
60027   int result;
60028
60029   {
60030     try {
60031       result = (int)Dali::Toolkit::ImageVisual::Property::FITTING_MODE;
60032     } catch (std::out_of_range& e) {
60033       {
60034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60035       };
60036     } catch (std::exception& e) {
60037       {
60038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60039       };
60040     } catch (Dali::DaliException e) {
60041       {
60042         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60043       };
60044     } catch (...) {
60045       {
60046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60047       };
60048     }
60049   }
60050
60051   jresult = (int)result;
60052   return jresult;
60053 }
60054
60055
60056 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SAMPLING_MODE_get() {
60057   int jresult ;
60058   int result;
60059
60060   {
60061     try {
60062       result = (int)Dali::Toolkit::ImageVisual::Property::SAMPLING_MODE;
60063     } catch (std::out_of_range& e) {
60064       {
60065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60066       };
60067     } catch (std::exception& e) {
60068       {
60069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60070       };
60071     } catch (Dali::DaliException e) {
60072       {
60073         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60074       };
60075     } catch (...) {
60076       {
60077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60078       };
60079     }
60080   }
60081
60082   jresult = (int)result;
60083   return jresult;
60084 }
60085
60086 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_RELEASE_POLICY_get() {
60087   int jresult ;
60088   int result;
60089   {
60090     try
60091     {
60092       result = (int)Dali::Toolkit::ImageVisual::Property::RELEASE_POLICY;
60093     } catch (std::out_of_range& e) {
60094       {
60095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60096       };
60097     } catch (std::exception& e) {
60098       {
60099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60100       };
60101     } catch (...) {
60102       {
60103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60104       };
60105     }
60106   }
60107   jresult = (int)result;
60108   return jresult;
60109 }
60110
60111 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_LOAD_POLICY_get() {
60112   int jresult ;
60113   int result;
60114   {
60115     try
60116     {
60117       result = (int)Dali::Toolkit::ImageVisual::Property::LOAD_POLICY;
60118     } catch (std::out_of_range& e) {
60119       {
60120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60121       };
60122     } catch (std::exception& e) {
60123       {
60124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60125       };
60126     } catch (...) {
60127       {
60128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60129       };
60130     }
60131   }
60132   jresult = (int)result;
60133   return jresult;
60134 }
60135
60136 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ORIENTATION_CORRECTION_get() {
60137   int jresult ;
60138   int result;
60139   {
60140     try
60141     {
60142       result = (int)Dali::Toolkit::ImageVisual::Property::ORIENTATION_CORRECTION;
60143     } catch (std::out_of_range& e) {
60144       {
60145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60146       };
60147     } catch (std::exception& e) {
60148       {
60149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60150       };
60151     } catch (...) {
60152       {
60153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60154       };
60155     }
60156   }
60157   jresult = (int)result;
60158   return jresult;
60159 }
60160
60161
60162 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_AUXILIARY_IMAGE_URL_get() {
60163   int jresult ;
60164   int result;
60165   {
60166     try
60167     {
60168       result = (int)Dali::Toolkit::DevelImageVisual::Property::AUXILIARY_IMAGE;
60169     } catch (std::out_of_range& e) {
60170       {
60171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60172       };
60173     } catch (std::exception& e) {
60174       {
60175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60176       };
60177     } catch (...) {
60178       {
60179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60180       };
60181     }
60182   }
60183   jresult = (int)result;
60184   return jresult;
60185 }
60186
60187 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_AUXILIARY_IMAGE_ALPHA_get() {
60188   int jresult ;
60189   int result;
60190   {
60191     try
60192     {
60193       result = (int)Dali::Toolkit::DevelImageVisual::Property::AUXILIARY_IMAGE_ALPHA;
60194     } catch (std::out_of_range& e) {
60195       {
60196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60197       };
60198     } catch (std::exception& e) {
60199       {
60200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60201       };
60202     } catch (...) {
60203       {
60204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60205       };
60206     }
60207   }
60208   jresult = (int)result;
60209   return jresult;
60210 }
60211
60212
60213
60214 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_WIDTH_get() {
60215   int jresult ;
60216   int result;
60217
60218   {
60219     try {
60220       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_WIDTH;
60221     } catch (std::out_of_range& e) {
60222       {
60223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60224       };
60225     } catch (std::exception& e) {
60226       {
60227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60228       };
60229     } catch (Dali::DaliException e) {
60230       {
60231         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60232       };
60233     } catch (...) {
60234       {
60235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60236       };
60237     }
60238   }
60239
60240   jresult = (int)result;
60241   return jresult;
60242 }
60243
60244
60245 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_HEIGHT_get() {
60246   int jresult ;
60247   int result;
60248
60249   {
60250     try {
60251       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_HEIGHT;
60252     } catch (std::out_of_range& e) {
60253       {
60254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60255       };
60256     } catch (std::exception& e) {
60257       {
60258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60259       };
60260     } catch (Dali::DaliException e) {
60261       {
60262         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60263       };
60264     } catch (...) {
60265       {
60266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60267       };
60268     }
60269   }
60270
60271   jresult = (int)result;
60272   return jresult;
60273 }
60274
60275
60276 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SYNCHRONOUS_LOADING_get() {
60277   int jresult ;
60278   int result;
60279
60280   {
60281     try {
60282       result = (int)Dali::Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING;
60283     } catch (std::out_of_range& e) {
60284       {
60285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60286       };
60287     } catch (std::exception& e) {
60288       {
60289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60290       };
60291     } catch (Dali::DaliException e) {
60292       {
60293         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60294       };
60295     } catch (...) {
60296       {
60297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60298       };
60299     }
60300   }
60301
60302   jresult = (int)result;
60303   return jresult;
60304 }
60305
60306
60307 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BORDER_ONLY_get() {
60308   int jresult ;
60309   int result;
60310
60311   {
60312     try {
60313       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER_ONLY;
60314     } catch (std::out_of_range& e) {
60315       {
60316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60317       };
60318     } catch (std::exception& e) {
60319       {
60320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60321       };
60322     } catch (Dali::DaliException e) {
60323       {
60324         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60325       };
60326     } catch (...) {
60327       {
60328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60329       };
60330     }
60331   }
60332
60333   jresult = (int)result;
60334   return jresult;
60335 }
60336
60337
60338 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_PIXEL_AREA_get() {
60339   int jresult ;
60340   int result;
60341
60342   {
60343     try {
60344       result = (int)Dali::Toolkit::ImageVisual::Property::PIXEL_AREA;
60345     } catch (std::out_of_range& e) {
60346       {
60347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60348       };
60349     } catch (std::exception& e) {
60350       {
60351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60352       };
60353     } catch (Dali::DaliException e) {
60354       {
60355         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60356       };
60357     } catch (...) {
60358       {
60359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60360       };
60361     }
60362   }
60363
60364   jresult = (int)result;
60365   return jresult;
60366 }
60367
60368
60369 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_U_get() {
60370   int jresult ;
60371   int result;
60372
60373   {
60374     try {
60375       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_U;
60376     } catch (std::out_of_range& e) {
60377       {
60378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60379       };
60380     } catch (std::exception& e) {
60381       {
60382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60383       };
60384     } catch (Dali::DaliException e) {
60385       {
60386         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60387       };
60388     } catch (...) {
60389       {
60390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60391       };
60392     }
60393   }
60394
60395   jresult = (int)result;
60396   return jresult;
60397 }
60398
60399
60400 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_V_get() {
60401   int jresult ;
60402   int result;
60403
60404   {
60405     try {
60406       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_V;
60407     } catch (std::out_of_range& e) {
60408       {
60409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60410       };
60411     } catch (std::exception& e) {
60412       {
60413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60414       };
60415     } catch (Dali::DaliException e) {
60416       {
60417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60418       };
60419     } catch (...) {
60420       {
60421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60422       };
60423     }
60424   }
60425
60426   jresult = (int)result;
60427   return jresult;
60428 }
60429
60430 SWIGEXPORT int SWIGSTDCALL CSharp_Image_Visual_BORDER_get() {
60431   int jresult ;
60432   int result;
60433
60434   {
60435     try {
60436       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER;
60437     } catch (std::out_of_range& e) {
60438       {
60439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60440       };
60441     } catch (std::exception& e) {
60442       {
60443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60444       };
60445     } catch (...) {
60446       {
60447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60448       };
60449     }
60450   }
60451   jresult = (int)result;
60452   return jresult;
60453 }
60454
60455 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_OBJECT_URL_get() {
60456   int jresult ;
60457   int result;
60458
60459   {
60460     try {
60461       result = (int)Dali::Toolkit::MeshVisual::Property::OBJECT_URL;
60462     } catch (std::out_of_range& e) {
60463       {
60464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60465       };
60466     } catch (std::exception& e) {
60467       {
60468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60469       };
60470     } catch (Dali::DaliException e) {
60471       {
60472         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60473       };
60474     } catch (...) {
60475       {
60476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60477       };
60478     }
60479   }
60480
60481   jresult = (int)result;
60482   return jresult;
60483 }
60484
60485
60486 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_MATERIAL_URL_get() {
60487   int jresult ;
60488   int result;
60489
60490   {
60491     try {
60492       result = (int)Dali::Toolkit::MeshVisual::Property::MATERIAL_URL;
60493     } catch (std::out_of_range& e) {
60494       {
60495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60496       };
60497     } catch (std::exception& e) {
60498       {
60499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60500       };
60501     } catch (Dali::DaliException e) {
60502       {
60503         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60504       };
60505     } catch (...) {
60506       {
60507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60508       };
60509     }
60510   }
60511
60512   jresult = (int)result;
60513   return jresult;
60514 }
60515
60516
60517 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_TEXTURES_PATH_get() {
60518   int jresult ;
60519   int result;
60520
60521   {
60522     try {
60523       result = (int)Dali::Toolkit::MeshVisual::Property::TEXTURES_PATH;
60524     } catch (std::out_of_range& e) {
60525       {
60526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60527       };
60528     } catch (std::exception& e) {
60529       {
60530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60531       };
60532     } catch (Dali::DaliException e) {
60533       {
60534         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60535       };
60536     } catch (...) {
60537       {
60538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60539       };
60540     }
60541   }
60542
60543   jresult = (int)result;
60544   return jresult;
60545 }
60546
60547
60548 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_SHADING_MODE_get() {
60549   int jresult ;
60550   int result;
60551
60552   {
60553     try {
60554       result = (int)Dali::Toolkit::MeshVisual::Property::SHADING_MODE;
60555     } catch (std::out_of_range& e) {
60556       {
60557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60558       };
60559     } catch (std::exception& e) {
60560       {
60561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60562       };
60563     } catch (Dali::DaliException e) {
60564       {
60565         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60566       };
60567     } catch (...) {
60568       {
60569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60570       };
60571     }
60572   }
60573
60574   jresult = (int)result;
60575   return jresult;
60576 }
60577
60578
60579 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_MIPMAPPING_get() {
60580   int jresult ;
60581   int result;
60582
60583   {
60584     try {
60585       result = (int)Dali::Toolkit::MeshVisual::Property::USE_MIPMAPPING;
60586     } catch (std::out_of_range& e) {
60587       {
60588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60589       };
60590     } catch (std::exception& e) {
60591       {
60592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60593       };
60594     } catch (Dali::DaliException e) {
60595       {
60596         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60597       };
60598     } catch (...) {
60599       {
60600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60601       };
60602     }
60603   }
60604
60605   jresult = (int)result;
60606   return jresult;
60607 }
60608
60609
60610 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_SOFT_NORMALS_get() {
60611   int jresult ;
60612   int result;
60613
60614   {
60615     try {
60616       result = (int)Dali::Toolkit::MeshVisual::Property::USE_SOFT_NORMALS;
60617     } catch (std::out_of_range& e) {
60618       {
60619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60620       };
60621     } catch (std::exception& e) {
60622       {
60623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60624       };
60625     } catch (Dali::DaliException e) {
60626       {
60627         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60628       };
60629     } catch (...) {
60630       {
60631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60632       };
60633     }
60634   }
60635
60636   jresult = (int)result;
60637   return jresult;
60638 }
60639
60640
60641 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_LIGHT_POSITION_get() {
60642   int jresult ;
60643   int result;
60644
60645   {
60646     try {
60647       result = (int)Dali::Toolkit::MeshVisual::Property::LIGHT_POSITION;
60648     } catch (std::out_of_range& e) {
60649       {
60650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60651       };
60652     } catch (std::exception& e) {
60653       {
60654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60655       };
60656     } catch (Dali::DaliException e) {
60657       {
60658         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60659       };
60660     } catch (...) {
60661       {
60662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60663       };
60664     }
60665   }
60666
60667   jresult = (int)result;
60668   return jresult;
60669 }
60670
60671
60672 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SHAPE_get() {
60673   int jresult ;
60674   int result;
60675
60676   {
60677     try {
60678       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SHAPE;
60679     } catch (std::out_of_range& e) {
60680       {
60681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60682       };
60683     } catch (std::exception& e) {
60684       {
60685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60686       };
60687     } catch (Dali::DaliException e) {
60688       {
60689         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60690       };
60691     } catch (...) {
60692       {
60693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60694       };
60695     }
60696   }
60697
60698   jresult = (int)result;
60699   return jresult;
60700 }
60701
60702
60703 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_MIX_COLOR_get() {
60704   int jresult ;
60705   int result;
60706
60707   {
60708     try {
60709       result = (int)Dali::Toolkit::PrimitiveVisual::Property::MIX_COLOR;
60710     } catch (std::out_of_range& e) {
60711       {
60712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60713       };
60714     } catch (std::exception& e) {
60715       {
60716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60717       };
60718     } catch (Dali::DaliException e) {
60719       {
60720         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60721       };
60722     } catch (...) {
60723       {
60724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60725       };
60726     }
60727   }
60728
60729   jresult = (int)result;
60730   return jresult;
60731 }
60732
60733
60734 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SLICES_get() {
60735   int jresult ;
60736   int result;
60737
60738   {
60739     try {
60740       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SLICES;
60741     } catch (std::out_of_range& e) {
60742       {
60743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60744       };
60745     } catch (std::exception& e) {
60746       {
60747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60748       };
60749     } catch (Dali::DaliException e) {
60750       {
60751         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60752       };
60753     } catch (...) {
60754       {
60755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60756       };
60757     }
60758   }
60759
60760   jresult = (int)result;
60761   return jresult;
60762 }
60763
60764
60765 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_STACKS_get() {
60766   int jresult ;
60767   int result;
60768
60769   {
60770     try {
60771       result = (int)Dali::Toolkit::PrimitiveVisual::Property::STACKS;
60772     } catch (std::out_of_range& e) {
60773       {
60774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60775       };
60776     } catch (std::exception& e) {
60777       {
60778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60779       };
60780     } catch (Dali::DaliException e) {
60781       {
60782         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60783       };
60784     } catch (...) {
60785       {
60786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60787       };
60788     }
60789   }
60790
60791   jresult = (int)result;
60792   return jresult;
60793 }
60794
60795
60796 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_TOP_RADIUS_get() {
60797   int jresult ;
60798   int result;
60799
60800   {
60801     try {
60802       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_TOP_RADIUS;
60803     } catch (std::out_of_range& e) {
60804       {
60805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60806       };
60807     } catch (std::exception& e) {
60808       {
60809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60810       };
60811     } catch (Dali::DaliException e) {
60812       {
60813         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60814       };
60815     } catch (...) {
60816       {
60817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60818       };
60819     }
60820   }
60821
60822   jresult = (int)result;
60823   return jresult;
60824 }
60825
60826
60827 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_BOTTOM_RADIUS_get() {
60828   int jresult ;
60829   int result;
60830
60831   {
60832     try {
60833       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS;
60834     } catch (std::out_of_range& e) {
60835       {
60836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60837       };
60838     } catch (std::exception& e) {
60839       {
60840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60841       };
60842     } catch (Dali::DaliException e) {
60843       {
60844         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60845       };
60846     } catch (...) {
60847       {
60848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60849       };
60850     }
60851   }
60852
60853   jresult = (int)result;
60854   return jresult;
60855 }
60856
60857
60858 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_HEIGHT_get() {
60859   int jresult ;
60860   int result;
60861
60862   {
60863     try {
60864       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_HEIGHT;
60865     } catch (std::out_of_range& e) {
60866       {
60867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60868       };
60869     } catch (std::exception& e) {
60870       {
60871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60872       };
60873     } catch (Dali::DaliException e) {
60874       {
60875         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60876       };
60877     } catch (...) {
60878       {
60879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60880       };
60881     }
60882   }
60883
60884   jresult = (int)result;
60885   return jresult;
60886 }
60887
60888
60889 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_RADIUS_get() {
60890   int jresult ;
60891   int result;
60892
60893   {
60894     try {
60895       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_RADIUS;
60896     } catch (std::out_of_range& e) {
60897       {
60898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60899       };
60900     } catch (std::exception& e) {
60901       {
60902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60903       };
60904     } catch (Dali::DaliException e) {
60905       {
60906         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60907       };
60908     } catch (...) {
60909       {
60910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60911       };
60912     }
60913   }
60914
60915   jresult = (int)result;
60916   return jresult;
60917 }
60918
60919
60920 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_DIMENSIONS_get() {
60921   int jresult ;
60922   int result;
60923
60924   {
60925     try {
60926       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_DIMENSIONS;
60927     } catch (std::out_of_range& e) {
60928       {
60929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60930       };
60931     } catch (std::exception& e) {
60932       {
60933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60934       };
60935     } catch (Dali::DaliException e) {
60936       {
60937         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60938       };
60939     } catch (...) {
60940       {
60941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60942       };
60943     }
60944   }
60945
60946   jresult = (int)result;
60947   return jresult;
60948 }
60949
60950
60951 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_PERCENTAGE_get() {
60952   int jresult ;
60953   int result;
60954
60955   {
60956     try {
60957       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_PERCENTAGE;
60958     } catch (std::out_of_range& e) {
60959       {
60960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60961       };
60962     } catch (std::exception& e) {
60963       {
60964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60965       };
60966     } catch (Dali::DaliException e) {
60967       {
60968         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60969       };
60970     } catch (...) {
60971       {
60972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60973       };
60974     }
60975   }
60976
60977   jresult = (int)result;
60978   return jresult;
60979 }
60980
60981
60982 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_SMOOTHNESS_get() {
60983   int jresult ;
60984   int result;
60985
60986   {
60987     try {
60988       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_SMOOTHNESS;
60989     } catch (std::out_of_range& e) {
60990       {
60991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60992       };
60993     } catch (std::exception& e) {
60994       {
60995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60996       };
60997     } catch (Dali::DaliException e) {
60998       {
60999         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61000       };
61001     } catch (...) {
61002       {
61003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61004       };
61005     }
61006   }
61007
61008   jresult = (int)result;
61009   return jresult;
61010 }
61011
61012
61013 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_LIGHT_POSITION_get() {
61014   int jresult ;
61015   int result;
61016
61017   {
61018     try {
61019       result = (int)Dali::Toolkit::PrimitiveVisual::Property::LIGHT_POSITION;
61020     } catch (std::out_of_range& e) {
61021       {
61022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61023       };
61024     } catch (std::exception& e) {
61025       {
61026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61027       };
61028     } catch (Dali::DaliException e) {
61029       {
61030         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61031       };
61032     } catch (...) {
61033       {
61034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61035       };
61036     }
61037   }
61038
61039   jresult = (int)result;
61040   return jresult;
61041 }
61042
61043
61044 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_get() {
61045   int jresult ;
61046   int result;
61047
61048   {
61049     try {
61050       result = (int)Dali::Toolkit::TextVisual::Property::TEXT;
61051     } catch (std::out_of_range& e) {
61052       {
61053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61054       };
61055     } catch (std::exception& e) {
61056       {
61057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61058       };
61059     } catch (Dali::DaliException e) {
61060       {
61061         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61062       };
61063     } catch (...) {
61064       {
61065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61066       };
61067     }
61068   }
61069
61070   jresult = (int)result;
61071   return jresult;
61072 }
61073
61074
61075 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_FAMILY_get() {
61076   int jresult ;
61077   int result;
61078
61079   {
61080     try {
61081       result = (int)Dali::Toolkit::TextVisual::Property::FONT_FAMILY;
61082     } catch (std::out_of_range& e) {
61083       {
61084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61085       };
61086     } catch (std::exception& e) {
61087       {
61088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61089       };
61090     } catch (Dali::DaliException e) {
61091       {
61092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61093       };
61094     } catch (...) {
61095       {
61096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61097       };
61098     }
61099   }
61100
61101   jresult = (int)result;
61102   return jresult;
61103 }
61104
61105
61106 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_STYLE_get() {
61107   int jresult ;
61108   int result;
61109
61110   {
61111     try {
61112       result = (int)Dali::Toolkit::TextVisual::Property::FONT_STYLE;
61113     } catch (std::out_of_range& e) {
61114       {
61115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61116       };
61117     } catch (std::exception& e) {
61118       {
61119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61120       };
61121     } catch (Dali::DaliException e) {
61122       {
61123         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61124       };
61125     } catch (...) {
61126       {
61127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61128       };
61129     }
61130   }
61131
61132   jresult = (int)result;
61133   return jresult;
61134 }
61135
61136
61137 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_POINT_SIZE_get() {
61138   int jresult ;
61139   int result;
61140
61141   {
61142     try {
61143       result = (int)Dali::Toolkit::TextVisual::Property::POINT_SIZE;
61144     } catch (std::out_of_range& e) {
61145       {
61146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61147       };
61148     } catch (std::exception& e) {
61149       {
61150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61151       };
61152     } catch (Dali::DaliException e) {
61153       {
61154         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61155       };
61156     } catch (...) {
61157       {
61158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61159       };
61160     }
61161   }
61162
61163   jresult = (int)result;
61164   return jresult;
61165 }
61166
61167
61168 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_MULTI_LINE_get() {
61169   int jresult ;
61170   int result;
61171
61172   {
61173     try {
61174       result = (int)Dali::Toolkit::TextVisual::Property::MULTI_LINE;
61175     } catch (std::out_of_range& e) {
61176       {
61177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61178       };
61179     } catch (std::exception& e) {
61180       {
61181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61182       };
61183     } catch (Dali::DaliException e) {
61184       {
61185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61186       };
61187     } catch (...) {
61188       {
61189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61190       };
61191     }
61192   }
61193
61194   jresult = (int)result;
61195   return jresult;
61196 }
61197
61198
61199 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_HORIZONTAL_ALIGNMENT_get() {
61200   int jresult ;
61201   int result;
61202
61203   {
61204     try {
61205       result = (int)Dali::Toolkit::TextVisual::Property::HORIZONTAL_ALIGNMENT;
61206     } catch (std::out_of_range& e) {
61207       {
61208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61209       };
61210     } catch (std::exception& e) {
61211       {
61212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61213       };
61214     } catch (Dali::DaliException e) {
61215       {
61216         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61217       };
61218     } catch (...) {
61219       {
61220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61221       };
61222     }
61223   }
61224
61225   jresult = (int)result;
61226   return jresult;
61227 }
61228
61229
61230 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_VERTICAL_ALIGNMENT_get() {
61231   int jresult ;
61232   int result;
61233
61234   {
61235     try {
61236       result = (int)Dali::Toolkit::TextVisual::Property::VERTICAL_ALIGNMENT;
61237     } catch (std::out_of_range& e) {
61238       {
61239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61240       };
61241     } catch (std::exception& e) {
61242       {
61243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61244       };
61245     } catch (Dali::DaliException e) {
61246       {
61247         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61248       };
61249     } catch (...) {
61250       {
61251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61252       };
61253     }
61254   }
61255
61256   jresult = (int)result;
61257   return jresult;
61258 }
61259
61260
61261 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_COLOR_get() {
61262   int jresult ;
61263   int result;
61264
61265   {
61266     try {
61267       result = (int)Dali::Toolkit::TextVisual::Property::TEXT_COLOR;
61268     } catch (std::out_of_range& e) {
61269       {
61270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61271       };
61272     } catch (std::exception& e) {
61273       {
61274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61275       };
61276     } catch (Dali::DaliException e) {
61277       {
61278         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61279       };
61280     } catch (...) {
61281       {
61282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61283       };
61284     }
61285   }
61286
61287   jresult = (int)result;
61288   return jresult;
61289 }
61290
61291
61292 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_ENABLE_MARKUP_get() {
61293   int jresult ;
61294   int result;
61295
61296   {
61297     try {
61298       result = (int)Dali::Toolkit::TextVisual::Property::ENABLE_MARKUP;
61299     } catch (std::out_of_range& e) {
61300       {
61301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61302       };
61303     } catch (std::exception& e) {
61304       {
61305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61306       };
61307     } catch (Dali::DaliException e) {
61308       {
61309         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61310       };
61311     } catch (...) {
61312       {
61313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61314       };
61315     }
61316   }
61317
61318   jresult = (int)result;
61319   return jresult;
61320 }
61321
61322
61323 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Builder() {
61324   void * jresult ;
61325   Dali::Toolkit::Builder *result = 0 ;
61326
61327   {
61328     try {
61329       result = (Dali::Toolkit::Builder *)new Dali::Toolkit::Builder();
61330     } catch (std::out_of_range& e) {
61331       {
61332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61333       };
61334     } catch (std::exception& e) {
61335       {
61336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61337       };
61338     } catch (Dali::DaliException e) {
61339       {
61340         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61341       };
61342     } catch (...) {
61343       {
61344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61345       };
61346     }
61347   }
61348
61349   jresult = (void *)result;
61350   return jresult;
61351 }
61352
61353
61354 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_New() {
61355   void * jresult ;
61356   Dali::Toolkit::Builder result;
61357
61358   {
61359     try {
61360       result = Dali::Toolkit::Builder::New();
61361     } catch (std::out_of_range& e) {
61362       {
61363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61364       };
61365     } catch (std::exception& e) {
61366       {
61367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61368       };
61369     } catch (Dali::DaliException e) {
61370       {
61371         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61372       };
61373     } catch (...) {
61374       {
61375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61376       };
61377     }
61378   }
61379
61380   jresult = new Dali::Toolkit::Builder((const Dali::Toolkit::Builder &)result);
61381   return jresult;
61382 }
61383
61384
61385 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Builder(void * jarg1) {
61386   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61387
61388   arg1 = (Dali::Toolkit::Builder *)jarg1;
61389   {
61390     try {
61391       delete arg1;
61392     } catch (std::out_of_range& e) {
61393       {
61394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61395       };
61396     } catch (std::exception& e) {
61397       {
61398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61399       };
61400     } catch (Dali::DaliException e) {
61401       {
61402         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61403       };
61404     } catch (...) {
61405       {
61406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61407       };
61408     }
61409   }
61410
61411 }
61412
61413
61414 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_0(void * jarg1, char * jarg2, int jarg3) {
61415   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61416   std::string *arg2 = 0 ;
61417   Dali::Toolkit::Builder::UIFormat arg3 ;
61418
61419   arg1 = (Dali::Toolkit::Builder *)jarg1;
61420   if (!jarg2) {
61421     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61422     return ;
61423   }
61424   std::string arg2_str(jarg2);
61425   arg2 = &arg2_str;
61426   arg3 = (Dali::Toolkit::Builder::UIFormat)jarg3;
61427   {
61428     try {
61429       (arg1)->LoadFromString((std::string const &)*arg2,arg3);
61430     } catch (std::out_of_range& e) {
61431       {
61432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61433       };
61434     } catch (std::exception& e) {
61435       {
61436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61437       };
61438     } catch (Dali::DaliException e) {
61439       {
61440         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61441       };
61442     } catch (...) {
61443       {
61444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61445       };
61446     }
61447   }
61448
61449
61450   //argout typemap for const std::string&
61451
61452 }
61453
61454
61455 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_1(void * jarg1, char * jarg2) {
61456   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61457   std::string *arg2 = 0 ;
61458
61459   arg1 = (Dali::Toolkit::Builder *)jarg1;
61460   if (!jarg2) {
61461     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61462     return ;
61463   }
61464   std::string arg2_str(jarg2);
61465   arg2 = &arg2_str;
61466   {
61467     try {
61468       (arg1)->LoadFromString((std::string const &)*arg2);
61469     } catch (std::out_of_range& e) {
61470       {
61471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61472       };
61473     } catch (std::exception& e) {
61474       {
61475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61476       };
61477     } catch (Dali::DaliException e) {
61478       {
61479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61480       };
61481     } catch (...) {
61482       {
61483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61484       };
61485     }
61486   }
61487
61488
61489   //argout typemap for const std::string&
61490
61491 }
61492
61493
61494 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstants(void * jarg1, void * jarg2) {
61495   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61496   Dali::Property::Map *arg2 = 0 ;
61497
61498   arg1 = (Dali::Toolkit::Builder *)jarg1;
61499   arg2 = (Dali::Property::Map *)jarg2;
61500   if (!arg2) {
61501     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
61502     return ;
61503   }
61504   {
61505     try {
61506       (arg1)->AddConstants((Dali::Property::Map const &)*arg2);
61507     } catch (std::out_of_range& e) {
61508       {
61509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61510       };
61511     } catch (std::exception& e) {
61512       {
61513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61514       };
61515     } catch (Dali::DaliException e) {
61516       {
61517         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61518       };
61519     } catch (...) {
61520       {
61521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61522       };
61523     }
61524   }
61525
61526 }
61527
61528
61529 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstant(void * jarg1, char * jarg2, void * jarg3) {
61530   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61531   std::string *arg2 = 0 ;
61532   Dali::Property::Value *arg3 = 0 ;
61533
61534   arg1 = (Dali::Toolkit::Builder *)jarg1;
61535   if (!jarg2) {
61536     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61537     return ;
61538   }
61539   std::string arg2_str(jarg2);
61540   arg2 = &arg2_str;
61541   arg3 = (Dali::Property::Value *)jarg3;
61542   if (!arg3) {
61543     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
61544     return ;
61545   }
61546   {
61547     try {
61548       (arg1)->AddConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
61549     } catch (std::out_of_range& e) {
61550       {
61551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61552       };
61553     } catch (std::exception& e) {
61554       {
61555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61556       };
61557     } catch (Dali::DaliException e) {
61558       {
61559         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61560       };
61561     } catch (...) {
61562       {
61563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61564       };
61565     }
61566   }
61567
61568
61569   //argout typemap for const std::string&
61570
61571 }
61572
61573
61574 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstants(void * jarg1) {
61575   void * jresult ;
61576   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61577   Dali::Property::Map *result = 0 ;
61578
61579   arg1 = (Dali::Toolkit::Builder *)jarg1;
61580   {
61581     try {
61582       result = (Dali::Property::Map *) &((Dali::Toolkit::Builder const *)arg1)->GetConstants();
61583     } catch (std::out_of_range& e) {
61584       {
61585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61586       };
61587     } catch (std::exception& e) {
61588       {
61589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61590       };
61591     } catch (Dali::DaliException e) {
61592       {
61593         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61594       };
61595     } catch (...) {
61596       {
61597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61598       };
61599     }
61600   }
61601
61602   jresult = (void *)result;
61603   return jresult;
61604 }
61605
61606
61607 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstant(void * jarg1, char * jarg2) {
61608   void * jresult ;
61609   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61610   std::string *arg2 = 0 ;
61611   Dali::Property::Value *result = 0 ;
61612
61613   arg1 = (Dali::Toolkit::Builder *)jarg1;
61614   if (!jarg2) {
61615     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61616     return 0;
61617   }
61618   std::string arg2_str(jarg2);
61619   arg2 = &arg2_str;
61620   {
61621     try {
61622       result = (Dali::Property::Value *) &((Dali::Toolkit::Builder const *)arg1)->GetConstant((std::string const &)*arg2);
61623     } catch (std::out_of_range& e) {
61624       {
61625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61626       };
61627     } catch (std::exception& e) {
61628       {
61629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61630       };
61631     } catch (Dali::DaliException e) {
61632       {
61633         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61634       };
61635     } catch (...) {
61636       {
61637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61638       };
61639     }
61640   }
61641
61642   jresult = (void *)result;
61643
61644   //argout typemap for const std::string&
61645
61646   return jresult;
61647 }
61648
61649
61650 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_0(void * jarg1, char * jarg2) {
61651   void * jresult ;
61652   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61653   std::string *arg2 = 0 ;
61654   Dali::Animation result;
61655
61656   arg1 = (Dali::Toolkit::Builder *)jarg1;
61657   if (!jarg2) {
61658     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61659     return 0;
61660   }
61661   std::string arg2_str(jarg2);
61662   arg2 = &arg2_str;
61663   {
61664     try {
61665       result = (arg1)->CreateAnimation((std::string const &)*arg2);
61666     } catch (std::out_of_range& e) {
61667       {
61668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61669       };
61670     } catch (std::exception& e) {
61671       {
61672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61673       };
61674     } catch (Dali::DaliException e) {
61675       {
61676         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61677       };
61678     } catch (...) {
61679       {
61680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61681       };
61682     }
61683   }
61684
61685   jresult = new Dali::Animation((const Dali::Animation &)result);
61686
61687   //argout typemap for const std::string&
61688
61689   return jresult;
61690 }
61691
61692
61693 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
61694   void * jresult ;
61695   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61696   std::string *arg2 = 0 ;
61697   Dali::Property::Map *arg3 = 0 ;
61698   Dali::Animation result;
61699
61700   arg1 = (Dali::Toolkit::Builder *)jarg1;
61701   if (!jarg2) {
61702     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61703     return 0;
61704   }
61705   std::string arg2_str(jarg2);
61706   arg2 = &arg2_str;
61707   arg3 = (Dali::Property::Map *)jarg3;
61708   if (!arg3) {
61709     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
61710     return 0;
61711   }
61712   {
61713     try {
61714       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
61715     } catch (std::out_of_range& e) {
61716       {
61717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61718       };
61719     } catch (std::exception& e) {
61720       {
61721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61722       };
61723     } catch (Dali::DaliException e) {
61724       {
61725         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61726       };
61727     } catch (...) {
61728       {
61729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61730       };
61731     }
61732   }
61733
61734   jresult = new Dali::Animation((const Dali::Animation &)result);
61735
61736   //argout typemap for const std::string&
61737
61738   return jresult;
61739 }
61740
61741
61742 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
61743   void * jresult ;
61744   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61745   std::string *arg2 = 0 ;
61746   Dali::Actor arg3 ;
61747   Dali::Actor *argp3 ;
61748   Dali::Animation result;
61749
61750   arg1 = (Dali::Toolkit::Builder *)jarg1;
61751   if (!jarg2) {
61752     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61753     return 0;
61754   }
61755   std::string arg2_str(jarg2);
61756   arg2 = &arg2_str;
61757   argp3 = (Dali::Actor *)jarg3;
61758   if (!argp3) {
61759     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61760     return 0;
61761   }
61762   arg3 = *argp3;
61763   {
61764     try {
61765       result = (arg1)->CreateAnimation((std::string const &)*arg2,arg3);
61766     } catch (std::out_of_range& e) {
61767       {
61768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61769       };
61770     } catch (std::exception& e) {
61771       {
61772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61773       };
61774     } catch (Dali::DaliException e) {
61775       {
61776         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61777       };
61778     } catch (...) {
61779       {
61780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61781       };
61782     }
61783   }
61784
61785   jresult = new Dali::Animation((const Dali::Animation &)result);
61786
61787   //argout typemap for const std::string&
61788
61789   return jresult;
61790 }
61791
61792
61793 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_3(void * jarg1, char * jarg2, void * jarg3, void * jarg4) {
61794   void * jresult ;
61795   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61796   std::string *arg2 = 0 ;
61797   Dali::Property::Map *arg3 = 0 ;
61798   Dali::Actor arg4 ;
61799   Dali::Actor *argp4 ;
61800   Dali::Animation result;
61801
61802   arg1 = (Dali::Toolkit::Builder *)jarg1;
61803   if (!jarg2) {
61804     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61805     return 0;
61806   }
61807   std::string arg2_str(jarg2);
61808   arg2 = &arg2_str;
61809   arg3 = (Dali::Property::Map *)jarg3;
61810   if (!arg3) {
61811     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
61812     return 0;
61813   }
61814   argp4 = (Dali::Actor *)jarg4;
61815   if (!argp4) {
61816     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61817     return 0;
61818   }
61819   arg4 = *argp4;
61820   {
61821     try {
61822       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3,arg4);
61823     } catch (std::out_of_range& e) {
61824       {
61825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61826       };
61827     } catch (std::exception& e) {
61828       {
61829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61830       };
61831     } catch (Dali::DaliException e) {
61832       {
61833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61834       };
61835     } catch (...) {
61836       {
61837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61838       };
61839     }
61840   }
61841
61842   jresult = new Dali::Animation((const Dali::Animation &)result);
61843
61844   //argout typemap for const std::string&
61845
61846   return jresult;
61847 }
61848
61849
61850 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_0(void * jarg1, char * jarg2) {
61851   void * jresult ;
61852   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61853   std::string *arg2 = 0 ;
61854   Dali::BaseHandle result;
61855
61856   arg1 = (Dali::Toolkit::Builder *)jarg1;
61857   if (!jarg2) {
61858     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61859     return 0;
61860   }
61861   std::string arg2_str(jarg2);
61862   arg2 = &arg2_str;
61863   {
61864     try {
61865       result = (arg1)->Create((std::string const &)*arg2);
61866     } catch (std::out_of_range& e) {
61867       {
61868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61869       };
61870     } catch (std::exception& e) {
61871       {
61872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61873       };
61874     } catch (Dali::DaliException e) {
61875       {
61876         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61877       };
61878     } catch (...) {
61879       {
61880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61881       };
61882     }
61883   }
61884
61885   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
61886
61887   //argout typemap for const std::string&
61888
61889   return jresult;
61890 }
61891
61892
61893 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
61894   void * jresult ;
61895   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61896   std::string *arg2 = 0 ;
61897   Dali::Property::Map *arg3 = 0 ;
61898   Dali::BaseHandle result;
61899
61900   arg1 = (Dali::Toolkit::Builder *)jarg1;
61901   if (!jarg2) {
61902     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61903     return 0;
61904   }
61905   std::string arg2_str(jarg2);
61906   arg2 = &arg2_str;
61907   arg3 = (Dali::Property::Map *)jarg3;
61908   if (!arg3) {
61909     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
61910     return 0;
61911   }
61912   {
61913     try {
61914       result = (arg1)->Create((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
61915     } catch (std::out_of_range& e) {
61916       {
61917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61918       };
61919     } catch (std::exception& e) {
61920       {
61921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61922       };
61923     } catch (Dali::DaliException e) {
61924       {
61925         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61926       };
61927     } catch (...) {
61928       {
61929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61930       };
61931     }
61932   }
61933
61934   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
61935
61936   //argout typemap for const std::string&
61937
61938   return jresult;
61939 }
61940
61941
61942 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateFromJson(void * jarg1, char * jarg2) {
61943   void * jresult ;
61944   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61945   std::string *arg2 = 0 ;
61946   Dali::BaseHandle result;
61947
61948   arg1 = (Dali::Toolkit::Builder *)jarg1;
61949   if (!jarg2) {
61950     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61951     return 0;
61952   }
61953   std::string arg2_str(jarg2);
61954   arg2 = &arg2_str;
61955   {
61956     try {
61957       result = (arg1)->CreateFromJson((std::string const &)*arg2);
61958     } catch (std::out_of_range& e) {
61959       {
61960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61961       };
61962     } catch (std::exception& e) {
61963       {
61964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61965       };
61966     } catch (Dali::DaliException e) {
61967       {
61968         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61969       };
61970     } catch (...) {
61971       {
61972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61973       };
61974     }
61975   }
61976
61977   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
61978
61979   //argout typemap for const std::string&
61980
61981   return jresult;
61982 }
61983
61984
61985 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyStyle(void * jarg1, char * jarg2, void * jarg3) {
61986   unsigned int jresult ;
61987   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61988   std::string *arg2 = 0 ;
61989   Dali::Handle *arg3 = 0 ;
61990   bool result;
61991
61992   arg1 = (Dali::Toolkit::Builder *)jarg1;
61993   if (!jarg2) {
61994     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61995     return 0;
61996   }
61997   std::string arg2_str(jarg2);
61998   arg2 = &arg2_str;
61999   arg3 = (Dali::Handle *)jarg3;
62000   if (!arg3) {
62001     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
62002     return 0;
62003   }
62004   {
62005     try {
62006       result = (bool)(arg1)->ApplyStyle((std::string const &)*arg2,*arg3);
62007     } catch (std::out_of_range& e) {
62008       {
62009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62010       };
62011     } catch (std::exception& e) {
62012       {
62013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62014       };
62015     } catch (Dali::DaliException e) {
62016       {
62017         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62018       };
62019     } catch (...) {
62020       {
62021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62022       };
62023     }
62024   }
62025
62026   jresult = result;
62027
62028   //argout typemap for const std::string&
62029
62030   return jresult;
62031 }
62032
62033
62034 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyFromJson(void * jarg1, void * jarg2, char * jarg3) {
62035   unsigned int jresult ;
62036   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62037   Dali::Handle *arg2 = 0 ;
62038   std::string *arg3 = 0 ;
62039   bool result;
62040
62041   arg1 = (Dali::Toolkit::Builder *)jarg1;
62042   arg2 = (Dali::Handle *)jarg2;
62043   if (!arg2) {
62044     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
62045     return 0;
62046   }
62047   if (!jarg3) {
62048     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62049     return 0;
62050   }
62051   std::string arg3_str(jarg3);
62052   arg3 = &arg3_str;
62053   {
62054     try {
62055       result = (bool)(arg1)->ApplyFromJson(*arg2,(std::string const &)*arg3);
62056     } catch (std::out_of_range& e) {
62057       {
62058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62059       };
62060     } catch (std::exception& e) {
62061       {
62062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62063       };
62064     } catch (Dali::DaliException e) {
62065       {
62066         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62067       };
62068     } catch (...) {
62069       {
62070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62071       };
62072     }
62073   }
62074
62075   jresult = result;
62076
62077   //argout typemap for const std::string&
62078
62079   return jresult;
62080 }
62081
62082
62083 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_0(void * jarg1, void * jarg2) {
62084   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62085   Dali::Actor arg2 ;
62086   Dali::Actor *argp2 ;
62087
62088   arg1 = (Dali::Toolkit::Builder *)jarg1;
62089   argp2 = (Dali::Actor *)jarg2;
62090   if (!argp2) {
62091     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62092     return ;
62093   }
62094   arg2 = *argp2;
62095   {
62096     try {
62097       (arg1)->AddActors(arg2);
62098     } catch (std::out_of_range& e) {
62099       {
62100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62101       };
62102     } catch (std::exception& e) {
62103       {
62104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62105       };
62106     } catch (Dali::DaliException e) {
62107       {
62108         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62109       };
62110     } catch (...) {
62111       {
62112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62113       };
62114     }
62115   }
62116
62117 }
62118
62119
62120 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
62121   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62122   std::string *arg2 = 0 ;
62123   Dali::Actor arg3 ;
62124   Dali::Actor *argp3 ;
62125
62126   arg1 = (Dali::Toolkit::Builder *)jarg1;
62127   if (!jarg2) {
62128     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62129     return ;
62130   }
62131   std::string arg2_str(jarg2);
62132   arg2 = &arg2_str;
62133   argp3 = (Dali::Actor *)jarg3;
62134   if (!argp3) {
62135     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62136     return ;
62137   }
62138   arg3 = *argp3;
62139   {
62140     try {
62141       (arg1)->AddActors((std::string const &)*arg2,arg3);
62142     } catch (std::out_of_range& e) {
62143       {
62144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62145       };
62146     } catch (std::exception& e) {
62147       {
62148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62149       };
62150     } catch (Dali::DaliException e) {
62151       {
62152         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62153       };
62154     } catch (...) {
62155       {
62156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62157       };
62158     }
62159   }
62160
62161
62162   //argout typemap for const std::string&
62163
62164 }
62165
62166
62167 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_CreateRenderTask(void * jarg1, char * jarg2) {
62168   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62169   std::string *arg2 = 0 ;
62170
62171   arg1 = (Dali::Toolkit::Builder *)jarg1;
62172   if (!jarg2) {
62173     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62174     return ;
62175   }
62176   std::string arg2_str(jarg2);
62177   arg2 = &arg2_str;
62178   {
62179     try {
62180       (arg1)->CreateRenderTask((std::string const &)*arg2);
62181     } catch (std::out_of_range& e) {
62182       {
62183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62184       };
62185     } catch (std::exception& e) {
62186       {
62187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62188       };
62189     } catch (Dali::DaliException e) {
62190       {
62191         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62192       };
62193     } catch (...) {
62194       {
62195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62196       };
62197     }
62198   }
62199
62200
62201   //argout typemap for const std::string&
62202
62203 }
62204
62205
62206 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetFrameBufferImage(void * jarg1, char * jarg2) {
62207   void * jresult ;
62208   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62209   std::string *arg2 = 0 ;
62210   Dali::FrameBufferImage result;
62211
62212   arg1 = (Dali::Toolkit::Builder *)jarg1;
62213   if (!jarg2) {
62214     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62215     return 0;
62216   }
62217   std::string arg2_str(jarg2);
62218   arg2 = &arg2_str;
62219   {
62220     try {
62221       result = (arg1)->GetFrameBufferImage((std::string const &)*arg2);
62222     } catch (std::out_of_range& e) {
62223       {
62224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62225       };
62226     } catch (std::exception& e) {
62227       {
62228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62229       };
62230     } catch (Dali::DaliException e) {
62231       {
62232         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62233       };
62234     } catch (...) {
62235       {
62236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62237       };
62238     }
62239   }
62240
62241   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
62242
62243   //argout typemap for const std::string&
62244
62245   return jresult;
62246 }
62247
62248
62249 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPath(void * jarg1, char * jarg2) {
62250   void * jresult ;
62251   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62252   std::string *arg2 = 0 ;
62253   Dali::Path result;
62254
62255   arg1 = (Dali::Toolkit::Builder *)jarg1;
62256   if (!jarg2) {
62257     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62258     return 0;
62259   }
62260   std::string arg2_str(jarg2);
62261   arg2 = &arg2_str;
62262   {
62263     try {
62264       result = (arg1)->GetPath((std::string const &)*arg2);
62265     } catch (std::out_of_range& e) {
62266       {
62267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62268       };
62269     } catch (std::exception& e) {
62270       {
62271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62272       };
62273     } catch (Dali::DaliException e) {
62274       {
62275         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62276       };
62277     } catch (...) {
62278       {
62279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62280       };
62281     }
62282   }
62283
62284   jresult = new Dali::Path((const Dali::Path &)result);
62285
62286   //argout typemap for const std::string&
62287
62288   return jresult;
62289 }
62290
62291
62292 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPathConstrainer(void * jarg1, char * jarg2) {
62293   void * jresult ;
62294   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62295   std::string *arg2 = 0 ;
62296   Dali::PathConstrainer result;
62297
62298   arg1 = (Dali::Toolkit::Builder *)jarg1;
62299   if (!jarg2) {
62300     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62301     return 0;
62302   }
62303   std::string arg2_str(jarg2);
62304   arg2 = &arg2_str;
62305   {
62306     try {
62307       result = (arg1)->GetPathConstrainer((std::string const &)*arg2);
62308     } catch (std::out_of_range& e) {
62309       {
62310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62311       };
62312     } catch (std::exception& e) {
62313       {
62314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62315       };
62316     } catch (Dali::DaliException e) {
62317       {
62318         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62319       };
62320     } catch (...) {
62321       {
62322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62323       };
62324     }
62325   }
62326
62327   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
62328
62329   //argout typemap for const std::string&
62330
62331   return jresult;
62332 }
62333
62334
62335 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetLinearConstrainer(void * jarg1, char * jarg2) {
62336   void * jresult ;
62337   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62338   std::string *arg2 = 0 ;
62339   Dali::LinearConstrainer result;
62340
62341   arg1 = (Dali::Toolkit::Builder *)jarg1;
62342   if (!jarg2) {
62343     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62344     return 0;
62345   }
62346   std::string arg2_str(jarg2);
62347   arg2 = &arg2_str;
62348   {
62349     try {
62350       result = (arg1)->GetLinearConstrainer((std::string const &)*arg2);
62351     } catch (std::out_of_range& e) {
62352       {
62353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62354       };
62355     } catch (std::exception& e) {
62356       {
62357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62358       };
62359     } catch (Dali::DaliException e) {
62360       {
62361         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62362       };
62363     } catch (...) {
62364       {
62365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62366       };
62367     }
62368   }
62369
62370   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
62371
62372   //argout typemap for const std::string&
62373
62374   return jresult;
62375 }
62376
62377
62378 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_QuitSignal(void * jarg1) {
62379   void * jresult ;
62380   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62381   Dali::Toolkit::Builder::BuilderSignalType *result = 0 ;
62382
62383   arg1 = (Dali::Toolkit::Builder *)jarg1;
62384   {
62385     try {
62386       result = (Dali::Toolkit::Builder::BuilderSignalType *) &(arg1)->QuitSignal();
62387     } catch (std::out_of_range& e) {
62388       {
62389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62390       };
62391     } catch (std::exception& e) {
62392       {
62393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62394       };
62395     } catch (Dali::DaliException e) {
62396       {
62397         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62398       };
62399     } catch (...) {
62400       {
62401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62402       };
62403     }
62404   }
62405
62406   jresult = (void *)result;
62407   return jresult;
62408 }
62409
62410
62411 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_0() {
62412   void * jresult ;
62413   Dali::Toolkit::TransitionData *result = 0 ;
62414
62415   {
62416     try {
62417       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData();
62418     } catch (std::out_of_range& e) {
62419       {
62420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62421       };
62422     } catch (std::exception& e) {
62423       {
62424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62425       };
62426     } catch (Dali::DaliException e) {
62427       {
62428         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62429       };
62430     } catch (...) {
62431       {
62432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62433       };
62434     }
62435   }
62436
62437   jresult = (void *)result;
62438   return jresult;
62439 }
62440
62441 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TransitionData(void * jarg1) {
62442   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
62443
62444   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62445   {
62446     try {
62447       delete arg1;
62448     } catch (std::out_of_range& e) {
62449       {
62450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62451       };
62452     } catch (std::exception& e) {
62453       {
62454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62455       };
62456     } catch (Dali::DaliException e) {
62457       {
62458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62459       };
62460     } catch (...) {
62461       {
62462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62463       };
62464     }
62465   }
62466
62467 }
62468
62469
62470 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_0(void * jarg1) {
62471   void * jresult ;
62472   Dali::Property::Map *arg1 = 0 ;
62473   Dali::Toolkit::TransitionData result;
62474
62475   arg1 = (Dali::Property::Map *)jarg1;
62476   if (!arg1) {
62477     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
62478     return 0;
62479   }
62480   {
62481     try {
62482       result = Dali::Toolkit::TransitionData::New((Dali::Property::Map const &)*arg1);
62483     } catch (std::out_of_range& e) {
62484       {
62485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62486       };
62487     } catch (std::exception& e) {
62488       {
62489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62490       };
62491     } catch (Dali::DaliException e) {
62492       {
62493         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62494       };
62495     } catch (...) {
62496       {
62497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62498       };
62499     }
62500   }
62501
62502   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
62503   return jresult;
62504 }
62505
62506
62507 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_1(void * jarg1) {
62508   void * jresult ;
62509   Dali::Property::Array *arg1 = 0 ;
62510   Dali::Toolkit::TransitionData result;
62511
62512   arg1 = (Dali::Property::Array *)jarg1;
62513   if (!arg1) {
62514     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
62515     return 0;
62516   }
62517   {
62518     try {
62519       result = Dali::Toolkit::TransitionData::New((Dali::Property::Array const &)*arg1);
62520     } catch (std::out_of_range& e) {
62521       {
62522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62523       };
62524     } catch (std::exception& e) {
62525       {
62526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62527       };
62528     } catch (Dali::DaliException e) {
62529       {
62530         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62531       };
62532     } catch (...) {
62533       {
62534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62535       };
62536     }
62537   }
62538
62539   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
62540   return jresult;
62541 }
62542
62543
62544 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_DownCast(void * jarg1) {
62545   void * jresult ;
62546   Dali::BaseHandle arg1 ;
62547   Dali::BaseHandle *argp1 ;
62548   Dali::Toolkit::TransitionData result;
62549
62550   argp1 = (Dali::BaseHandle *)jarg1;
62551   if (!argp1) {
62552     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
62553     return 0;
62554   }
62555   arg1 = *argp1;
62556   {
62557     try {
62558       result = Dali::Toolkit::TransitionData::DownCast(arg1);
62559     } catch (std::out_of_range& e) {
62560       {
62561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62562       };
62563     } catch (std::exception& e) {
62564       {
62565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62566       };
62567     } catch (Dali::DaliException e) {
62568       {
62569         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62570       };
62571     } catch (...) {
62572       {
62573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62574       };
62575     }
62576   }
62577
62578   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
62579   return jresult;
62580 }
62581
62582
62583 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_1(void * jarg1) {
62584   void * jresult ;
62585   Dali::Toolkit::TransitionData *arg1 = 0 ;
62586   Dali::Toolkit::TransitionData *result = 0 ;
62587
62588   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62589   if (!arg1) {
62590     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
62591     return 0;
62592   }
62593   {
62594     try {
62595       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData((Dali::Toolkit::TransitionData const &)*arg1);
62596     } catch (std::out_of_range& e) {
62597       {
62598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62599       };
62600     } catch (std::exception& e) {
62601       {
62602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62603       };
62604     } catch (Dali::DaliException e) {
62605       {
62606         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62607       };
62608     } catch (...) {
62609       {
62610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62611       };
62612     }
62613   }
62614
62615   jresult = (void *)result;
62616   return jresult;
62617 }
62618
62619
62620 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_Assign(void * jarg1, void * jarg2) {
62621   void * jresult ;
62622   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
62623   Dali::Toolkit::TransitionData *arg2 = 0 ;
62624   Dali::Toolkit::TransitionData *result = 0 ;
62625
62626   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62627   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
62628   if (!arg2) {
62629     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
62630     return 0;
62631   }
62632   {
62633     try {
62634       result = (Dali::Toolkit::TransitionData *) &(arg1)->operator =((Dali::Toolkit::TransitionData const &)*arg2);
62635     } catch (std::out_of_range& e) {
62636       {
62637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62638       };
62639     } catch (std::exception& e) {
62640       {
62641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62642       };
62643     } catch (Dali::DaliException e) {
62644       {
62645         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62646       };
62647     } catch (...) {
62648       {
62649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62650       };
62651     }
62652   }
62653
62654   jresult = (void *)result;
62655   return jresult;
62656 }
62657
62658
62659 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TransitionData_Count(void * jarg1) {
62660   unsigned long jresult ;
62661   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
62662   size_t result;
62663
62664   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62665   {
62666     try {
62667       result = ((Dali::Toolkit::TransitionData const *)arg1)->Count();
62668     } catch (std::out_of_range& e) {
62669       {
62670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62671       };
62672     } catch (std::exception& e) {
62673       {
62674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62675       };
62676     } catch (Dali::DaliException e) {
62677       {
62678         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62679       };
62680     } catch (...) {
62681       {
62682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62683       };
62684     }
62685   }
62686
62687   jresult = (unsigned long)result;
62688   return jresult;
62689 }
62690
62691
62692 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_GetAnimatorAt(void * jarg1, unsigned long jarg2) {
62693   void * jresult ;
62694   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
62695   size_t arg2 ;
62696   Dali::Property::Map result;
62697
62698   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62699   arg2 = (size_t)jarg2;
62700   {
62701     try {
62702       result = (arg1)->GetAnimatorAt(arg2);
62703     } catch (std::out_of_range& e) {
62704       {
62705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62706       };
62707     } catch (std::exception& e) {
62708       {
62709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62710       };
62711     } catch (Dali::DaliException e) {
62712       {
62713         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62714       };
62715     } catch (...) {
62716       {
62717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62718       };
62719     }
62720   }
62721
62722   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
62723   return jresult;
62724 }
62725
62726
62727 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_CONTENT_get() {
62728   int jresult ;
62729   int result;
62730
62731   {
62732     try {
62733       result = (int)Dali::Toolkit::Tooltip::Property::CONTENT;
62734     } catch (std::out_of_range& e) {
62735       {
62736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62737       };
62738     } catch (std::exception& e) {
62739       {
62740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62741       };
62742     } catch (Dali::DaliException e) {
62743       {
62744         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62745       };
62746     } catch (...) {
62747       {
62748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62749       };
62750     }
62751   }
62752
62753   jresult = (int)result;
62754   return jresult;
62755 }
62756
62757
62758 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_LAYOUT_get() {
62759   int jresult ;
62760   int result;
62761
62762   {
62763     try {
62764       result = (int)Dali::Toolkit::Tooltip::Property::LAYOUT;
62765     } catch (std::out_of_range& e) {
62766       {
62767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62768       };
62769     } catch (std::exception& e) {
62770       {
62771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62772       };
62773     } catch (Dali::DaliException e) {
62774       {
62775         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62776       };
62777     } catch (...) {
62778       {
62779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62780       };
62781     }
62782   }
62783
62784   jresult = (int)result;
62785   return jresult;
62786 }
62787
62788
62789 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_WAIT_TIME_get() {
62790   int jresult ;
62791   int result;
62792
62793   {
62794     try {
62795       result = (int)Dali::Toolkit::Tooltip::Property::WAIT_TIME;
62796     } catch (std::out_of_range& e) {
62797       {
62798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62799       };
62800     } catch (std::exception& e) {
62801       {
62802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62803       };
62804     } catch (Dali::DaliException e) {
62805       {
62806         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62807       };
62808     } catch (...) {
62809       {
62810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62811       };
62812     }
62813   }
62814
62815   jresult = (int)result;
62816   return jresult;
62817 }
62818
62819
62820 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_get() {
62821   int jresult ;
62822   int result;
62823
62824   {
62825     try {
62826       result = (int)Dali::Toolkit::Tooltip::Property::BACKGROUND;
62827     } catch (std::out_of_range& e) {
62828       {
62829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62830       };
62831     } catch (std::exception& e) {
62832       {
62833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62834       };
62835     } catch (Dali::DaliException e) {
62836       {
62837         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62838       };
62839     } catch (...) {
62840       {
62841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62842       };
62843     }
62844   }
62845
62846   jresult = (int)result;
62847   return jresult;
62848 }
62849
62850
62851 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_get() {
62852   int jresult ;
62853   int result;
62854
62855   {
62856     try {
62857       result = (int)Dali::Toolkit::Tooltip::Property::TAIL;
62858     } catch (std::out_of_range& e) {
62859       {
62860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62861       };
62862     } catch (std::exception& e) {
62863       {
62864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62865       };
62866     } catch (Dali::DaliException e) {
62867       {
62868         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62869       };
62870     } catch (...) {
62871       {
62872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62873       };
62874     }
62875   }
62876
62877   jresult = (int)result;
62878   return jresult;
62879 }
62880
62881
62882 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_POSITION_get() {
62883   int jresult ;
62884   int result;
62885
62886   {
62887     try {
62888       result = (int)Dali::Toolkit::Tooltip::Property::POSITION;
62889     } catch (std::out_of_range& e) {
62890       {
62891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62892       };
62893     } catch (std::exception& e) {
62894       {
62895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62896       };
62897     } catch (Dali::DaliException e) {
62898       {
62899         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62900       };
62901     } catch (...) {
62902       {
62903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62904       };
62905     }
62906   }
62907
62908   jresult = (int)result;
62909   return jresult;
62910 }
62911
62912
62913 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_HOVER_POINT_OFFSET_get() {
62914   int jresult ;
62915   int result;
62916
62917   {
62918     try {
62919       result = (int)Dali::Toolkit::Tooltip::Property::HOVER_POINT_OFFSET;
62920     } catch (std::out_of_range& e) {
62921       {
62922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62923       };
62924     } catch (std::exception& e) {
62925       {
62926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62927       };
62928     } catch (Dali::DaliException e) {
62929       {
62930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62931       };
62932     } catch (...) {
62933       {
62934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62935       };
62936     }
62937   }
62938
62939   jresult = (int)result;
62940   return jresult;
62941 }
62942
62943
62944 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_MOVEMENT_THRESHOLD_get() {
62945   int jresult ;
62946   int result;
62947
62948   {
62949     try {
62950       result = (int)Dali::Toolkit::Tooltip::Property::MOVEMENT_THRESHOLD;
62951     } catch (std::out_of_range& e) {
62952       {
62953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62954       };
62955     } catch (std::exception& e) {
62956       {
62957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62958       };
62959     } catch (Dali::DaliException e) {
62960       {
62961         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62962       };
62963     } catch (...) {
62964       {
62965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62966       };
62967     }
62968   }
62969
62970   jresult = (int)result;
62971   return jresult;
62972 }
62973
62974
62975 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_DISAPPEAR_ON_MOVEMENT_get() {
62976   int jresult ;
62977   int result;
62978
62979   {
62980     try {
62981       result = (int)Dali::Toolkit::Tooltip::Property::DISAPPEAR_ON_MOVEMENT;
62982     } catch (std::out_of_range& e) {
62983       {
62984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62985       };
62986     } catch (std::exception& e) {
62987       {
62988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62989       };
62990     } catch (Dali::DaliException e) {
62991       {
62992         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62993       };
62994     } catch (...) {
62995       {
62996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62997       };
62998     }
62999   }
63000
63001   jresult = (int)result;
63002   return jresult;
63003 }
63004
63005
63006 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_VISUAL_get() {
63007   int jresult ;
63008   int result;
63009
63010   {
63011     try {
63012       result = (int)Dali::Toolkit::Tooltip::Background::Property::VISUAL;
63013     } catch (std::out_of_range& e) {
63014       {
63015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63016       };
63017     } catch (std::exception& e) {
63018       {
63019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63020       };
63021     } catch (Dali::DaliException e) {
63022       {
63023         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63024       };
63025     } catch (...) {
63026       {
63027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63028       };
63029     }
63030   }
63031
63032   jresult = (int)result;
63033   return jresult;
63034 }
63035
63036
63037 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_BORDER_get() {
63038   int jresult ;
63039   int result;
63040
63041   {
63042     try {
63043       result = (int)Dali::Toolkit::Tooltip::Background::Property::BORDER;
63044     } catch (std::out_of_range& e) {
63045       {
63046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63047       };
63048     } catch (std::exception& e) {
63049       {
63050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63051       };
63052     } catch (Dali::DaliException e) {
63053       {
63054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63055       };
63056     } catch (...) {
63057       {
63058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63059       };
63060     }
63061   }
63062
63063   jresult = (int)result;
63064   return jresult;
63065 }
63066
63067
63068 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_VISIBILITY_get() {
63069   int jresult ;
63070   int result;
63071
63072   {
63073     try {
63074       result = (int)Dali::Toolkit::Tooltip::Tail::Property::VISIBILITY;
63075     } catch (std::out_of_range& e) {
63076       {
63077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63078       };
63079     } catch (std::exception& e) {
63080       {
63081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63082       };
63083     } catch (Dali::DaliException e) {
63084       {
63085         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63086       };
63087     } catch (...) {
63088       {
63089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63090       };
63091     }
63092   }
63093
63094   jresult = (int)result;
63095   return jresult;
63096 }
63097
63098
63099 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_ABOVE_VISUAL_get() {
63100   int jresult ;
63101   int result;
63102
63103   {
63104     try {
63105       result = (int)Dali::Toolkit::Tooltip::Tail::Property::ABOVE_VISUAL;
63106     } catch (std::out_of_range& e) {
63107       {
63108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63109       };
63110     } catch (std::exception& e) {
63111       {
63112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63113       };
63114     } catch (Dali::DaliException e) {
63115       {
63116         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63117       };
63118     } catch (...) {
63119       {
63120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63121       };
63122     }
63123   }
63124
63125   jresult = (int)result;
63126   return jresult;
63127 }
63128
63129
63130 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_BELOW_VISUAL_get() {
63131   int jresult ;
63132   int result;
63133
63134   {
63135     try {
63136       result = (int)Dali::Toolkit::Tooltip::Tail::Property::BELOW_VISUAL;
63137     } catch (std::out_of_range& e) {
63138       {
63139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63140       };
63141     } catch (std::exception& e) {
63142       {
63143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63144       };
63145     } catch (Dali::DaliException e) {
63146       {
63147         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63148       };
63149     } catch (...) {
63150       {
63151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63152       };
63153     }
63154   }
63155
63156   jresult = (int)result;
63157   return jresult;
63158 }
63159
63160
63161 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_New() {
63162   void * jresult ;
63163   Dali::Toolkit::Control result;
63164
63165   {
63166     try {
63167       result = Dali::Toolkit::Internal::Control::New();
63168     } catch (std::out_of_range& e) {
63169       {
63170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63171       };
63172     } catch (std::exception& e) {
63173       {
63174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63175       };
63176     } catch (Dali::DaliException e) {
63177       {
63178         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63179       };
63180     } catch (...) {
63181       {
63182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63183       };
63184     }
63185   }
63186
63187   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
63188   return jresult;
63189 }
63190
63191
63192 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetStyleName(void * jarg1, char * jarg2) {
63193   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63194   std::string *arg2 = 0 ;
63195
63196   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63197   if (!jarg2) {
63198     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
63199     return ;
63200   }
63201   std::string arg2_str(jarg2);
63202   arg2 = &arg2_str;
63203   {
63204     try {
63205       (arg1)->SetStyleName((std::string const &)*arg2);
63206     } catch (std::out_of_range& e) {
63207       {
63208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63209       };
63210     } catch (std::exception& e) {
63211       {
63212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63213       };
63214     } catch (Dali::DaliException e) {
63215       {
63216         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63217       };
63218     } catch (...) {
63219       {
63220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63221       };
63222     }
63223   }
63224
63225
63226   //argout typemap for const std::string&
63227
63228 }
63229
63230
63231 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ViewImpl_GetStyleName(void * jarg1) {
63232   char * jresult ;
63233   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63234   std::string *result = 0 ;
63235
63236   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63237   {
63238     try {
63239       result = (std::string *) &((Dali::Toolkit::Internal::Control const *)arg1)->GetStyleName();
63240     } catch (std::out_of_range& e) {
63241       {
63242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63243       };
63244     } catch (std::exception& e) {
63245       {
63246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63247       };
63248     } catch (Dali::DaliException e) {
63249       {
63250         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63251       };
63252     } catch (...) {
63253       {
63254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63255       };
63256     }
63257   }
63258
63259   jresult = SWIG_csharp_string_callback(result->c_str());
63260   return jresult;
63261 }
63262
63263
63264 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundColor(void * jarg1, void * jarg2) {
63265   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63266   Dali::Vector4 *arg2 = 0 ;
63267
63268   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63269   arg2 = (Dali::Vector4 *)jarg2;
63270   if (!arg2) {
63271     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
63272     return ;
63273   }
63274   {
63275     try {
63276       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
63277     } catch (std::out_of_range& e) {
63278       {
63279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63280       };
63281     } catch (std::exception& e) {
63282       {
63283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63284       };
63285     } catch (Dali::DaliException e) {
63286       {
63287         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63288       };
63289     } catch (...) {
63290       {
63291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63292       };
63293     }
63294   }
63295
63296 }
63297
63298
63299 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetBackgroundColor(void * jarg1) {
63300   void * jresult ;
63301   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63302   Dali::Vector4 result;
63303
63304   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63305   {
63306     try {
63307       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetBackgroundColor();
63308     } catch (std::out_of_range& e) {
63309       {
63310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63311       };
63312     } catch (std::exception& e) {
63313       {
63314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63315       };
63316     } catch (Dali::DaliException e) {
63317       {
63318         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63319       };
63320     } catch (...) {
63321       {
63322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63323       };
63324     }
63325   }
63326
63327   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
63328   return jresult;
63329 }
63330
63331
63332 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundImage(void * jarg1, void * jarg2) {
63333   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63334   Dali::Image arg2 ;
63335   Dali::Image *argp2 ;
63336
63337   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63338   argp2 = (Dali::Image *)jarg2;
63339   if (!argp2) {
63340     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
63341     return ;
63342   }
63343   arg2 = *argp2;
63344   {
63345     try {
63346       (arg1)->SetBackgroundImage(arg2);
63347     } catch (std::out_of_range& e) {
63348       {
63349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63350       };
63351     } catch (std::exception& e) {
63352       {
63353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63354       };
63355     } catch (Dali::DaliException e) {
63356       {
63357         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63358       };
63359     } catch (...) {
63360       {
63361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63362       };
63363     }
63364   }
63365
63366 }
63367
63368
63369 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackground(void * jarg1, void * jarg2) {
63370   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63371   Dali::Property::Map *arg2 = 0 ;
63372
63373   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63374   arg2 = (Dali::Property::Map *)jarg2;
63375   if (!arg2) {
63376     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
63377     return ;
63378   }
63379   {
63380     try {
63381       (arg1)->SetBackground((Dali::Property::Map const &)*arg2);
63382     } catch (std::out_of_range& e) {
63383       {
63384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63385       };
63386     } catch (std::exception& e) {
63387       {
63388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63389       };
63390     } catch (Dali::DaliException e) {
63391       {
63392         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63393       };
63394     } catch (...) {
63395       {
63396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63397       };
63398     }
63399   }
63400
63401 }
63402
63403
63404 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearBackground(void * jarg1) {
63405   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63406
63407   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63408   {
63409     try {
63410       (arg1)->ClearBackground();
63411     } catch (std::out_of_range& e) {
63412       {
63413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63414       };
63415     } catch (std::exception& e) {
63416       {
63417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63418       };
63419     } catch (Dali::DaliException e) {
63420       {
63421         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63422       };
63423     } catch (...) {
63424       {
63425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63426       };
63427     }
63428   }
63429
63430 }
63431
63432
63433 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_EnableGestureDetection(void * jarg1, int jarg2) {
63434   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63435   Dali::Gesture::Type arg2 ;
63436
63437   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63438   arg2 = (Dali::Gesture::Type)jarg2;
63439   {
63440     try {
63441       (arg1)->EnableGestureDetection(arg2);
63442     } catch (std::out_of_range& e) {
63443       {
63444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63445       };
63446     } catch (std::exception& e) {
63447       {
63448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63449       };
63450     } catch (Dali::DaliException e) {
63451       {
63452         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63453       };
63454     } catch (...) {
63455       {
63456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63457       };
63458     }
63459   }
63460
63461 }
63462
63463
63464 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_DisableGestureDetection(void * jarg1, int jarg2) {
63465   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63466   Dali::Gesture::Type arg2 ;
63467
63468   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63469   arg2 = (Dali::Gesture::Type)jarg2;
63470   {
63471     try {
63472       (arg1)->DisableGestureDetection(arg2);
63473     } catch (std::out_of_range& e) {
63474       {
63475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63476       };
63477     } catch (std::exception& e) {
63478       {
63479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63480       };
63481     } catch (Dali::DaliException e) {
63482       {
63483         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63484       };
63485     } catch (...) {
63486       {
63487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63488       };
63489     }
63490   }
63491
63492 }
63493
63494
63495 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPinchGestureDetector(void * jarg1) {
63496   void * jresult ;
63497   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63498   Dali::PinchGestureDetector result;
63499
63500   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63501   {
63502     try {
63503       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPinchGestureDetector();
63504     } catch (std::out_of_range& e) {
63505       {
63506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63507       };
63508     } catch (std::exception& e) {
63509       {
63510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63511       };
63512     } catch (Dali::DaliException e) {
63513       {
63514         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63515       };
63516     } catch (...) {
63517       {
63518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63519       };
63520     }
63521   }
63522
63523   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
63524   return jresult;
63525 }
63526
63527
63528 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPanGestureDetector(void * jarg1) {
63529   void * jresult ;
63530   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63531   Dali::PanGestureDetector result;
63532
63533   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63534   {
63535     try {
63536       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPanGestureDetector();
63537     } catch (std::out_of_range& e) {
63538       {
63539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63540       };
63541     } catch (std::exception& e) {
63542       {
63543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63544       };
63545     } catch (Dali::DaliException e) {
63546       {
63547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63548       };
63549     } catch (...) {
63550       {
63551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63552       };
63553     }
63554   }
63555
63556   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
63557   return jresult;
63558 }
63559
63560
63561 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetTapGestureDetector(void * jarg1) {
63562   void * jresult ;
63563   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63564   Dali::TapGestureDetector result;
63565
63566   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63567   {
63568     try {
63569       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetTapGestureDetector();
63570     } catch (std::out_of_range& e) {
63571       {
63572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63573       };
63574     } catch (std::exception& e) {
63575       {
63576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63577       };
63578     } catch (Dali::DaliException e) {
63579       {
63580         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63581       };
63582     } catch (...) {
63583       {
63584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63585       };
63586     }
63587   }
63588
63589   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
63590   return jresult;
63591 }
63592
63593
63594 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetLongPressGestureDetector(void * jarg1) {
63595   void * jresult ;
63596   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63597   Dali::LongPressGestureDetector result;
63598
63599   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63600   {
63601     try {
63602       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetLongPressGestureDetector();
63603     } catch (std::out_of_range& e) {
63604       {
63605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63606       };
63607     } catch (std::exception& e) {
63608       {
63609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63610       };
63611     } catch (Dali::DaliException e) {
63612       {
63613         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63614       };
63615     } catch (...) {
63616       {
63617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63618       };
63619     }
63620   }
63621
63622   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
63623   return jresult;
63624 }
63625
63626
63627 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyboardNavigationSupport(void * jarg1, unsigned int jarg2) {
63628   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63629   bool arg2 ;
63630
63631   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63632   arg2 = jarg2 ? true : false;
63633   {
63634     try {
63635       (arg1)->SetKeyboardNavigationSupport(arg2);
63636     } catch (std::out_of_range& e) {
63637       {
63638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63639       };
63640     } catch (std::exception& e) {
63641       {
63642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63643       };
63644     } catch (Dali::DaliException e) {
63645       {
63646         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63647       };
63648     } catch (...) {
63649       {
63650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63651       };
63652     }
63653   }
63654
63655 }
63656
63657
63658 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardNavigationSupported(void * jarg1) {
63659   unsigned int jresult ;
63660   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63661   bool result;
63662
63663   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63664   {
63665     try {
63666       result = (bool)(arg1)->IsKeyboardNavigationSupported();
63667     } catch (std::out_of_range& e) {
63668       {
63669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63670       };
63671     } catch (std::exception& e) {
63672       {
63673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63674       };
63675     } catch (Dali::DaliException e) {
63676       {
63677         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63678       };
63679     } catch (...) {
63680       {
63681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63682       };
63683     }
63684   }
63685
63686   jresult = result;
63687   return jresult;
63688 }
63689
63690
63691 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyInputFocus(void * jarg1) {
63692   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63693
63694   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63695   {
63696     try {
63697       (arg1)->SetKeyInputFocus();
63698     } catch (std::out_of_range& e) {
63699       {
63700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63701       };
63702     } catch (std::exception& e) {
63703       {
63704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63705       };
63706     } catch (Dali::DaliException e) {
63707       {
63708         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63709       };
63710     } catch (...) {
63711       {
63712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63713       };
63714     }
63715   }
63716
63717 }
63718
63719
63720 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_HasKeyInputFocus(void * jarg1) {
63721   unsigned int jresult ;
63722   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63723   bool result;
63724
63725   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63726   {
63727     try {
63728       result = (bool)(arg1)->HasKeyInputFocus();
63729     } catch (std::out_of_range& e) {
63730       {
63731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63732       };
63733     } catch (std::exception& e) {
63734       {
63735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63736       };
63737     } catch (Dali::DaliException e) {
63738       {
63739         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63740       };
63741     } catch (...) {
63742       {
63743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63744       };
63745     }
63746   }
63747
63748   jresult = result;
63749   return jresult;
63750 }
63751
63752
63753 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearKeyInputFocus(void * jarg1) {
63754   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63755
63756   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63757   {
63758     try {
63759       (arg1)->ClearKeyInputFocus();
63760     } catch (std::out_of_range& e) {
63761       {
63762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63763       };
63764     } catch (std::exception& e) {
63765       {
63766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63767       };
63768     } catch (Dali::DaliException e) {
63769       {
63770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63771       };
63772     } catch (...) {
63773       {
63774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63775       };
63776     }
63777   }
63778
63779 }
63780
63781
63782 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetAsKeyboardFocusGroup(void * jarg1, unsigned int jarg2) {
63783   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63784   bool arg2 ;
63785
63786   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63787   arg2 = jarg2 ? true : false;
63788   {
63789     try {
63790       (arg1)->SetAsKeyboardFocusGroup(arg2);
63791     } catch (std::out_of_range& e) {
63792       {
63793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63794       };
63795     } catch (std::exception& e) {
63796       {
63797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63798       };
63799     } catch (Dali::DaliException e) {
63800       {
63801         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63802       };
63803     } catch (...) {
63804       {
63805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63806       };
63807     }
63808   }
63809
63810 }
63811
63812
63813 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardFocusGroup(void * jarg1) {
63814   unsigned int jresult ;
63815   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63816   bool result;
63817
63818   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63819   {
63820     try {
63821       result = (bool)(arg1)->IsKeyboardFocusGroup();
63822     } catch (std::out_of_range& e) {
63823       {
63824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63825       };
63826     } catch (std::exception& e) {
63827       {
63828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63829       };
63830     } catch (Dali::DaliException e) {
63831       {
63832         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63833       };
63834     } catch (...) {
63835       {
63836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63837       };
63838     }
63839   }
63840
63841   jresult = result;
63842   return jresult;
63843 }
63844
63845
63846 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyEventSignal(void * jarg1) {
63847   void * jresult ;
63848   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63849   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
63850
63851   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63852   {
63853     try {
63854       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
63855     } catch (std::out_of_range& e) {
63856       {
63857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63858       };
63859     } catch (std::exception& e) {
63860       {
63861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63862       };
63863     } catch (Dali::DaliException e) {
63864       {
63865         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63866       };
63867     } catch (...) {
63868       {
63869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63870       };
63871     }
63872   }
63873
63874   jresult = (void *)result;
63875   return jresult;
63876 }
63877
63878
63879 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusGainedSignal(void * jarg1) {
63880   void * jresult ;
63881   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63882   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
63883
63884   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63885   {
63886     try {
63887       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
63888     } catch (std::out_of_range& e) {
63889       {
63890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63891       };
63892     } catch (std::exception& e) {
63893       {
63894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63895       };
63896     } catch (Dali::DaliException e) {
63897       {
63898         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63899       };
63900     } catch (...) {
63901       {
63902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63903       };
63904     }
63905   }
63906
63907   jresult = (void *)result;
63908   return jresult;
63909 }
63910
63911
63912 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusLostSignal(void * jarg1) {
63913   void * jresult ;
63914   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63915   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
63916
63917   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63918   {
63919     try {
63920       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
63921     } catch (std::out_of_range& e) {
63922       {
63923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63924       };
63925     } catch (std::exception& e) {
63926       {
63927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63928       };
63929     } catch (Dali::DaliException e) {
63930       {
63931         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63932       };
63933     } catch (...) {
63934       {
63935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63936       };
63937     }
63938   }
63939
63940   jresult = (void *)result;
63941   return jresult;
63942 }
63943
63944
63945 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageConnection(void * jarg1, int jarg2) {
63946   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63947   int arg2 ;
63948   SwigDirector_ViewImpl *darg = 0;
63949
63950   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63951   arg2 = (int)jarg2;
63952   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63953   if(!darg) {
63954     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63955     return;
63956   }
63957   {
63958     try {
63959       if(darg) {
63960         (darg)->OnStageConnection(arg2);
63961       }
63962     } catch (std::out_of_range& e) {
63963       {
63964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63965       };
63966     } catch (std::exception& e) {
63967       {
63968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63969       };
63970     } catch (Dali::DaliException e) {
63971       {
63972         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63973       };
63974     } catch (...) {
63975       {
63976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63977       };
63978     }
63979   }
63980
63981 }
63982
63983
63984 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageConnectionSwigExplicitViewImpl(void * jarg1, int jarg2) {
63985   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63986   int arg2 ;
63987   SwigDirector_ViewImpl *darg = 0;
63988
63989   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63990   arg2 = (int)jarg2;
63991   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63992   if(!darg) {
63993     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63994     return;
63995   }
63996   {
63997     try {
63998       if(darg) {
63999         (darg)->OnStageConnectionSwigPublic(arg2);
64000       }
64001     } catch (std::out_of_range& e) {
64002       {
64003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64004       };
64005     } catch (std::exception& e) {
64006       {
64007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64008       };
64009     } catch (Dali::DaliException e) {
64010       {
64011         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64012       };
64013     } catch (...) {
64014       {
64015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64016       };
64017     }
64018   }
64019
64020 }
64021
64022
64023 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageDisconnection(void * jarg1) {
64024   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64025   SwigDirector_ViewImpl *darg = 0;
64026
64027   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64028   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64029   if(!darg) {
64030     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64031     return;
64032   }
64033   {
64034     try {
64035       if(darg) {
64036         (darg)->OnStageDisconnection();
64037       }
64038     } catch (std::out_of_range& e) {
64039       {
64040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64041       };
64042     } catch (std::exception& e) {
64043       {
64044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64045       };
64046     } catch (Dali::DaliException e) {
64047       {
64048         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64049       };
64050     } catch (...) {
64051       {
64052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64053       };
64054     }
64055   }
64056
64057 }
64058
64059
64060 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageDisconnectionSwigExplicitViewImpl(void * jarg1) {
64061   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64062   SwigDirector_ViewImpl *darg = 0;
64063
64064   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64065   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64066   if(!darg) {
64067     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64068     return;
64069   }
64070   {
64071     try {
64072       if(darg) {
64073         (darg)->OnStageDisconnectionSwigPublic();
64074       }
64075     } catch (std::out_of_range& e) {
64076       {
64077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64078       };
64079     } catch (std::exception& e) {
64080       {
64081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64082       };
64083     } catch (Dali::DaliException e) {
64084       {
64085         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64086       };
64087     } catch (...) {
64088       {
64089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64090       };
64091     }
64092   }
64093
64094 }
64095
64096
64097 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAdd(void * jarg1, void * jarg2) {
64098   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64099   Dali::Actor *arg2 = 0 ;
64100   SwigDirector_ViewImpl *darg = 0;
64101
64102   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64103   arg2 = (Dali::Actor *)jarg2;
64104   if (!arg2) {
64105     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
64106     return ;
64107   }
64108   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64109   if(!darg) {
64110     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64111     return;
64112   }
64113   {
64114     try {
64115       if(darg) {
64116         (darg)->OnChildAdd(*arg2);
64117       }
64118     } catch (std::out_of_range& e) {
64119       {
64120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64121       };
64122     } catch (std::exception& e) {
64123       {
64124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64125       };
64126     } catch (Dali::DaliException e) {
64127       {
64128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64129       };
64130     } catch (...) {
64131       {
64132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64133       };
64134     }
64135   }
64136
64137 }
64138
64139
64140 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64141   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64142   Dali::Actor *arg2 = 0 ;
64143   SwigDirector_ViewImpl *darg = 0;
64144
64145   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64146   arg2 = (Dali::Actor *)jarg2;
64147   if (!arg2) {
64148     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
64149     return ;
64150   }
64151   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64152   if(!darg) {
64153     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64154     return;
64155   }
64156   {
64157     try {
64158       if(darg) {
64159           (darg)->OnChildAddSwigPublic(*arg2);
64160       }
64161     } catch (std::out_of_range& e) {
64162       {
64163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64164       };
64165     } catch (std::exception& e) {
64166       {
64167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64168       };
64169     } catch (Dali::DaliException e) {
64170       {
64171         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64172       };
64173     } catch (...) {
64174       {
64175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64176       };
64177     }
64178   }
64179
64180 }
64181
64182
64183 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemove(void * jarg1, void * jarg2) {
64184   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64185   Dali::Actor *arg2 = 0 ;
64186   SwigDirector_ViewImpl *darg = 0;
64187
64188   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64189   arg2 = (Dali::Actor *)jarg2;
64190   if (!arg2) {
64191     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
64192     return ;
64193   }
64194   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64195   if(!darg) {
64196     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64197     return;
64198   }
64199   {
64200     try {
64201       if(darg) {
64202         (darg)->OnChildRemove(*arg2);
64203       }
64204     } catch (std::out_of_range& e) {
64205       {
64206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64207       };
64208     } catch (std::exception& e) {
64209       {
64210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64211       };
64212     } catch (Dali::DaliException e) {
64213       {
64214         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64215       };
64216     } catch (...) {
64217       {
64218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64219       };
64220     }
64221   }
64222
64223 }
64224
64225
64226 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64227   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64228   Dali::Actor *arg2 = 0 ;
64229   SwigDirector_ViewImpl *darg = 0;
64230
64231   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64232   arg2 = (Dali::Actor *)jarg2;
64233   if (!arg2) {
64234     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
64235     return ;
64236   }
64237   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64238   if(!darg) {
64239     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64240     return;
64241   }
64242   {
64243     try {
64244       if(darg) {
64245         (darg)->OnChildRemoveSwigPublic(*arg2);
64246       }
64247     } catch (std::out_of_range& e) {
64248       {
64249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64250       };
64251     } catch (std::exception& e) {
64252       {
64253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64254       };
64255     } catch (Dali::DaliException e) {
64256       {
64257         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64258       };
64259     } catch (...) {
64260       {
64261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64262       };
64263     }
64264   }
64265
64266 }
64267
64268
64269 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
64270   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64271   Dali::Property::Index arg2 ;
64272   Dali::Property::Value arg3 ;
64273   Dali::Property::Value *argp3 ;
64274   SwigDirector_ViewImpl *darg = 0;
64275
64276   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64277   arg2 = (Dali::Property::Index)jarg2;
64278   argp3 = (Dali::Property::Value *)jarg3;
64279   if (!argp3) {
64280     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
64281     return ;
64282   }
64283   arg3 = *argp3;
64284   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64285   if (!darg) {
64286     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64287     return;
64288   }
64289   {
64290     try {
64291       (darg)->OnPropertySet(arg2,arg3);
64292     } catch (std::out_of_range& e) {
64293       {
64294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64295       };
64296     } catch (std::exception& e) {
64297       {
64298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64299       };
64300     } catch (Dali::DaliException e) {
64301       {
64302         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64303       };
64304     } catch (...) {
64305       {
64306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64307       };
64308     }
64309   }
64310
64311 }
64312
64313
64314 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySetSwigExplicitViewImpl(void * jarg1, int jarg2, void * jarg3) {
64315   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64316   Dali::Property::Index arg2 ;
64317   Dali::Property::Value arg3 ;
64318   Dali::Property::Value *argp3 ;
64319   SwigDirector_ViewImpl *darg = 0;
64320
64321   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64322   arg2 = (Dali::Property::Index)jarg2;
64323   argp3 = (Dali::Property::Value *)jarg3;
64324   if (!argp3) {
64325     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
64326     return ;
64327   }
64328   arg3 = *argp3;
64329   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64330   if (!darg) {
64331     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64332     return;
64333   }
64334   {
64335     try {
64336       (darg)->OnPropertySetSwigPublic(arg2,arg3);
64337     } catch (std::out_of_range& e) {
64338       {
64339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64340       };
64341     } catch (std::exception& e) {
64342       {
64343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64344       };
64345     } catch (Dali::DaliException e) {
64346       {
64347         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64348       };
64349     } catch (...) {
64350       {
64351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64352       };
64353     }
64354   }
64355
64356 }
64357
64358
64359 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSet(void * jarg1, void * jarg2) {
64360   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64361   Dali::Vector3 *arg2 = 0 ;
64362   SwigDirector_ViewImpl *darg = 0;
64363
64364   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64365   arg2 = (Dali::Vector3 *)jarg2;
64366   if (!arg2) {
64367     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64368     return ;
64369   }
64370   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64371   if (!darg) {
64372     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64373     return;
64374   }
64375   {
64376     try {
64377       (darg)->OnSizeSet((Dali::Vector3 const &)*arg2);
64378     } catch (std::out_of_range& e) {
64379       {
64380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64381       };
64382     } catch (std::exception& e) {
64383       {
64384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64385       };
64386     } catch (Dali::DaliException e) {
64387       {
64388         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64389       };
64390     } catch (...) {
64391       {
64392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64393       };
64394     }
64395   }
64396
64397 }
64398
64399
64400 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSetSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64401   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64402   Dali::Vector3 *arg2 = 0 ;
64403   SwigDirector_ViewImpl *darg = 0;
64404
64405   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64406   arg2 = (Dali::Vector3 *)jarg2;
64407   if (!arg2) {
64408     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64409     return ;
64410   }
64411   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64412   if (!darg) {
64413     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64414     return;
64415   }
64416   {
64417     try {
64418       (darg)->OnSizeSetSwigPublic((Dali::Vector3 const &)*arg2);
64419     } catch (std::out_of_range& e) {
64420       {
64421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64422       };
64423     } catch (std::exception& e) {
64424       {
64425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64426       };
64427     } catch (Dali::DaliException e) {
64428       {
64429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64430       };
64431     } catch (...) {
64432       {
64433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64434       };
64435     }
64436   }
64437
64438 }
64439
64440
64441 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
64442   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64443   Dali::Animation *arg2 = 0 ;
64444   Dali::Vector3 *arg3 = 0 ;
64445   SwigDirector_ViewImpl *darg = 0;
64446
64447   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64448   arg2 = (Dali::Animation *)jarg2;
64449   if (!arg2) {
64450     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
64451     return ;
64452   }
64453   arg3 = (Dali::Vector3 *)jarg3;
64454   if (!arg3) {
64455     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64456     return ;
64457   }
64458   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64459   if (!darg) {
64460     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64461     return;
64462   }
64463   {
64464     try {
64465       (darg)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
64466     } catch (std::out_of_range& e) {
64467       {
64468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64469       };
64470     } catch (std::exception& e) {
64471       {
64472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64473       };
64474     } catch (Dali::DaliException e) {
64475       {
64476         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64477       };
64478     } catch (...) {
64479       {
64480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64481       };
64482     }
64483   }
64484
64485 }
64486
64487
64488 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimationSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
64489   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64490   Dali::Animation *arg2 = 0 ;
64491   Dali::Vector3 *arg3 = 0 ;
64492   SwigDirector_ViewImpl *darg = 0;
64493
64494   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64495   arg2 = (Dali::Animation *)jarg2;
64496   if (!arg2) {
64497     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
64498     return ;
64499   }
64500   arg3 = (Dali::Vector3 *)jarg3;
64501   if (!arg3) {
64502     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64503     return ;
64504   }
64505   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64506   if (!darg) {
64507     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64508     return;
64509   }
64510   {
64511     try {
64512       (darg)->OnSizeAnimationSwigPublic(*arg2,(Dali::Vector3 const &)*arg3);
64513     } catch (std::out_of_range& e) {
64514       {
64515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64516       };
64517     } catch (std::exception& e) {
64518       {
64519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64520       };
64521     } catch (Dali::DaliException e) {
64522       {
64523         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64524       };
64525     } catch (...) {
64526       {
64527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64528       };
64529     }
64530   }
64531
64532 }
64533
64534
64535 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEvent(void * jarg1, void * jarg2) {
64536   unsigned int jresult ;
64537   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64538   Dali::TouchEvent *arg2 = 0 ;
64539   SwigDirector_ViewImpl *darg = 0;
64540   bool result;
64541
64542   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64543   arg2 = (Dali::TouchEvent *)jarg2;
64544   if (!arg2) {
64545     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
64546     return 0;
64547   }
64548   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64549   if (!darg) {
64550     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64551     return 0;
64552   }
64553   {
64554     try {
64555       result = (bool)(darg)->OnTouchEvent((Dali::TouchEvent const &)*arg2);
64556     } catch (std::out_of_range& e) {
64557       {
64558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64559       };
64560     } catch (std::exception& e) {
64561       {
64562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64563       };
64564     } catch (Dali::DaliException e) {
64565       {
64566         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64567       };
64568     } catch (...) {
64569       {
64570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64571       };
64572     }
64573   }
64574
64575   jresult = result;
64576   return jresult;
64577 }
64578
64579
64580 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64581   unsigned int jresult ;
64582   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64583   Dali::TouchEvent *arg2 = 0 ;
64584   SwigDirector_ViewImpl *darg = 0;
64585   bool result;
64586
64587   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64588   arg2 = (Dali::TouchEvent *)jarg2;
64589   if (!arg2) {
64590     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
64591     return 0;
64592   }
64593   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64594   if (!darg) {
64595     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64596     return 0;
64597   }
64598   {
64599     try {
64600       result = (bool)(darg)->OnTouchEventSwigPublic((Dali::TouchEvent const &)*arg2);
64601     } catch (std::out_of_range& e) {
64602       {
64603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64604       };
64605     } catch (std::exception& e) {
64606       {
64607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64608       };
64609     } catch (Dali::DaliException e) {
64610       {
64611         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64612       };
64613     } catch (...) {
64614       {
64615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64616       };
64617     }
64618   }
64619
64620   jresult = result;
64621   return jresult;
64622 }
64623
64624
64625 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEvent(void * jarg1, void * jarg2) {
64626   unsigned int jresult ;
64627   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64628   Dali::HoverEvent *arg2 = 0 ;
64629   SwigDirector_ViewImpl *darg = 0;
64630   bool result;
64631
64632   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64633   arg2 = (Dali::HoverEvent *)jarg2;
64634   if (!arg2) {
64635     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
64636     return 0;
64637   }
64638   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64639   if (!darg) {
64640     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64641     return 0;
64642   }
64643   {
64644     try {
64645       result = (bool)(darg)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
64646     } catch (std::out_of_range& e) {
64647       {
64648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64649       };
64650     } catch (std::exception& e) {
64651       {
64652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64653       };
64654     } catch (Dali::DaliException e) {
64655       {
64656         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64657       };
64658     } catch (...) {
64659       {
64660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64661       };
64662     }
64663   }
64664
64665   jresult = result;
64666   return jresult;
64667 }
64668
64669
64670 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64671   unsigned int jresult ;
64672   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64673   Dali::HoverEvent *arg2 = 0 ;
64674   SwigDirector_ViewImpl *darg = 0;
64675   bool result;
64676
64677   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64678   arg2 = (Dali::HoverEvent *)jarg2;
64679   if (!arg2) {
64680     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
64681     return 0;
64682   }
64683   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64684   if (!darg) {
64685     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64686     return 0;
64687   }
64688   {
64689     try {
64690       result = (bool)(darg)->OnHoverEventSwigPublic((Dali::HoverEvent const &)*arg2);
64691     } catch (std::out_of_range& e) {
64692       {
64693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64694       };
64695     } catch (std::exception& e) {
64696       {
64697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64698       };
64699     } catch (Dali::DaliException e) {
64700       {
64701         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64702       };
64703     } catch (...) {
64704       {
64705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64706       };
64707     }
64708   }
64709
64710   jresult = result;
64711   return jresult;
64712 }
64713
64714
64715 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEvent(void * jarg1, void * jarg2) {
64716   unsigned int jresult ;
64717   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64718   Dali::KeyEvent *arg2 = 0 ;
64719   SwigDirector_ViewImpl *darg = 0;
64720   bool result;
64721
64722   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64723   arg2 = (Dali::KeyEvent *)jarg2;
64724   if (!arg2) {
64725     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
64726     return 0;
64727   }
64728   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64729   if (!darg) {
64730     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64731     return 0;
64732   }
64733   {
64734     try {
64735       result = (bool)(darg)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
64736     } catch (std::out_of_range& e) {
64737       {
64738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64739       };
64740     } catch (std::exception& e) {
64741       {
64742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64743       };
64744     } catch (Dali::DaliException e) {
64745       {
64746         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64747       };
64748     } catch (...) {
64749       {
64750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64751       };
64752     }
64753   }
64754
64755   jresult = result;
64756   return jresult;
64757 }
64758
64759
64760 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64761   unsigned int jresult ;
64762   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64763   Dali::KeyEvent *arg2 = 0 ;
64764   SwigDirector_ViewImpl *darg = 0;
64765   bool result;
64766
64767   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64768   arg2 = (Dali::KeyEvent *)jarg2;
64769   if (!arg2) {
64770     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
64771     return 0;
64772   }
64773   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64774   if (!darg) {
64775     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64776     return 0;
64777   }
64778   {
64779     try {
64780       result = (bool)(darg)->OnKeyEventSwigPublic((Dali::KeyEvent const &)*arg2);
64781     } catch (std::out_of_range& e) {
64782       {
64783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64784       };
64785     } catch (std::exception& e) {
64786       {
64787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64788       };
64789     } catch (Dali::DaliException e) {
64790       {
64791         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64792       };
64793     } catch (...) {
64794       {
64795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64796       };
64797     }
64798   }
64799
64800   jresult = result;
64801   return jresult;
64802 }
64803
64804
64805 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEvent(void * jarg1, void * jarg2) {
64806   unsigned int jresult ;
64807   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64808   Dali::WheelEvent *arg2 = 0 ;
64809   SwigDirector_ViewImpl *darg = 0;
64810   bool result;
64811
64812   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64813   arg2 = (Dali::WheelEvent *)jarg2;
64814   if (!arg2) {
64815     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
64816     return 0;
64817   }
64818   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64819   if (!darg) {
64820     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64821     return 0;
64822   }
64823   {
64824     try {
64825       result = (bool)(darg)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
64826     } catch (std::out_of_range& e) {
64827       {
64828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64829       };
64830     } catch (std::exception& e) {
64831       {
64832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64833       };
64834     } catch (Dali::DaliException e) {
64835       {
64836         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64837       };
64838     } catch (...) {
64839       {
64840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64841       };
64842     }
64843   }
64844
64845   jresult = result;
64846   return jresult;
64847 }
64848
64849
64850 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64851   unsigned int jresult ;
64852   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64853   Dali::WheelEvent *arg2 = 0 ;
64854   SwigDirector_ViewImpl *darg = 0;
64855   bool result;
64856
64857   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64858   arg2 = (Dali::WheelEvent *)jarg2;
64859   if (!arg2) {
64860     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
64861     return 0;
64862   }
64863   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64864   if (!darg) {
64865     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64866     return 0;
64867   }
64868   {
64869     try {
64870       result = (bool)(darg)->OnWheelEventSwigPublic((Dali::WheelEvent const &)*arg2);
64871     } catch (std::out_of_range& e) {
64872       {
64873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64874       };
64875     } catch (std::exception& e) {
64876       {
64877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64878       };
64879     } catch (Dali::DaliException e) {
64880       {
64881         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64882       };
64883     } catch (...) {
64884       {
64885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64886       };
64887     }
64888   }
64889
64890   jresult = result;
64891   return jresult;
64892 }
64893
64894
64895 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
64896   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64897   Dali::Vector2 *arg2 = 0 ;
64898   Dali::RelayoutContainer *arg3 = 0 ;
64899   SwigDirector_ViewImpl *darg = 0;
64900
64901   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64902   arg2 = (Dali::Vector2 *)jarg2;
64903   if (!arg2) {
64904     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
64905     return ;
64906   }
64907   arg3 = (Dali::RelayoutContainer *)jarg3;
64908   if (!arg3) {
64909     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
64910     return ;
64911   }
64912   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64913   if (!darg) {
64914     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64915     return;
64916   }
64917   {
64918     try {
64919       (darg)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
64920     } catch (std::out_of_range& e) {
64921       {
64922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64923       };
64924     } catch (std::exception& e) {
64925       {
64926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64927       };
64928     } catch (Dali::DaliException e) {
64929       {
64930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64931       };
64932     } catch (...) {
64933       {
64934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64935       };
64936     }
64937   }
64938
64939 }
64940
64941
64942 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayoutSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
64943   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64944   Dali::Vector2 *arg2 = 0 ;
64945   Dali::RelayoutContainer *arg3 = 0 ;
64946   SwigDirector_ViewImpl *darg = 0;
64947
64948   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64949   arg2 = (Dali::Vector2 *)jarg2;
64950   if (!arg2) {
64951     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
64952     return ;
64953   }
64954   arg3 = (Dali::RelayoutContainer *)jarg3;
64955   if (!arg3) {
64956     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
64957     return ;
64958   }
64959   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64960   if (!darg) {
64961     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64962     return;
64963   }
64964   {
64965     try {
64966       (darg)->OnRelayoutSwigPublic((Dali::Vector2 const &)*arg2,*arg3);
64967     } catch (std::out_of_range& e) {
64968       {
64969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64970       };
64971     } catch (std::exception& e) {
64972       {
64973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64974       };
64975     } catch (Dali::DaliException e) {
64976       {
64977         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64978       };
64979     } catch (...) {
64980       {
64981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64982       };
64983     }
64984   }
64985
64986 }
64987
64988
64989 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
64990   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64991   Dali::ResizePolicy::Type arg2 ;
64992   Dali::Dimension::Type arg3 ;
64993   SwigDirector_ViewImpl *darg = 0;
64994
64995   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64996   arg2 = (Dali::ResizePolicy::Type)jarg2;
64997   arg3 = (Dali::Dimension::Type)jarg3;
64998   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64999   if (!darg) {
65000     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65001     return;
65002   }
65003   {
65004     try {
65005       (darg)->OnSetResizePolicy(arg2,arg3);
65006     } catch (std::out_of_range& e) {
65007       {
65008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65009       };
65010     } catch (std::exception& e) {
65011       {
65012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65013       };
65014     } catch (Dali::DaliException e) {
65015       {
65016         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65017       };
65018     } catch (...) {
65019       {
65020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65021       };
65022     }
65023   }
65024
65025 }
65026
65027
65028 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicySwigExplicitViewImpl(void * jarg1, int jarg2, int jarg3) {
65029   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65030   Dali::ResizePolicy::Type arg2 ;
65031   Dali::Dimension::Type arg3 ;
65032   SwigDirector_ViewImpl *darg = 0;
65033
65034   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65035   arg2 = (Dali::ResizePolicy::Type)jarg2;
65036   arg3 = (Dali::Dimension::Type)jarg3;
65037   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65038   if (!darg) {
65039     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65040     return;
65041   }
65042   {
65043     try {
65044       (darg)->OnSetResizePolicySwigPublic(arg2,arg3);
65045     } catch (std::out_of_range& e) {
65046       {
65047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65048       };
65049     } catch (std::exception& e) {
65050       {
65051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65052       };
65053     } catch (Dali::DaliException e) {
65054       {
65055         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65056       };
65057     } catch (...) {
65058       {
65059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65060       };
65061     }
65062   }
65063
65064 }
65065
65066
65067 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSize(void * jarg1) {
65068   void * jresult ;
65069   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65070   SwigDirector_ViewImpl *darg = 0;
65071   Dali::Vector3 result;
65072
65073   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65074   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65075   if (!darg) {
65076     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65077     return 0;
65078   }
65079   {
65080     try {
65081       result = (darg)->GetNaturalSize();
65082     } catch (std::out_of_range& e) {
65083       {
65084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65085       };
65086     } catch (std::exception& e) {
65087       {
65088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65089       };
65090     } catch (Dali::DaliException e) {
65091       {
65092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65093       };
65094     } catch (...) {
65095       {
65096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65097       };
65098     }
65099   }
65100
65101   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
65102   return jresult;
65103 }
65104
65105
65106 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSizeSwigExplicitViewImpl(void * jarg1) {
65107   void * jresult ;
65108   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65109   SwigDirector_ViewImpl *darg = 0;
65110   Dali::Vector3 result;
65111
65112   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65113   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65114   if (!darg) {
65115     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65116     return 0;
65117   }
65118   {
65119     try {
65120       result = (darg)->GetNaturalSizeSwigPublic();
65121     } catch (std::out_of_range& e) {
65122       {
65123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65124       };
65125     } catch (std::exception& e) {
65126       {
65127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65128       };
65129     } catch (Dali::DaliException e) {
65130       {
65131         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65132       };
65133     } catch (...) {
65134       {
65135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65136       };
65137     }
65138   }
65139
65140   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
65141   return jresult;
65142 }
65143
65144
65145 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
65146   float jresult ;
65147   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65148   Dali::Actor *arg2 = 0 ;
65149   Dali::Dimension::Type arg3 ;
65150   SwigDirector_ViewImpl *darg = 0;
65151   float result;
65152
65153   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65154   arg2 = (Dali::Actor *)jarg2;
65155   if (!arg2) {
65156     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
65157     return 0;
65158   }
65159   arg3 = (Dali::Dimension::Type)jarg3;
65160   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65161   if (!darg) {
65162     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65163     return 0;
65164   }
65165   {
65166     try {
65167       result = (float)(darg)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
65168     } catch (std::out_of_range& e) {
65169       {
65170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65171       };
65172     } catch (std::exception& e) {
65173       {
65174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65175       };
65176     } catch (Dali::DaliException e) {
65177       {
65178         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65179       };
65180     } catch (...) {
65181       {
65182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65183       };
65184     }
65185   }
65186
65187   jresult = result;
65188   return jresult;
65189 }
65190
65191
65192 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSizeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
65193   float jresult ;
65194   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65195   Dali::Actor *arg2 = 0 ;
65196   Dali::Dimension::Type arg3 ;
65197   SwigDirector_ViewImpl *darg = 0;
65198   float result;
65199
65200   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65201   arg2 = (Dali::Actor *)jarg2;
65202   if (!arg2) {
65203     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
65204     return 0;
65205   }
65206   arg3 = (Dali::Dimension::Type)jarg3;
65207   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65208   if (!darg) {
65209     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65210     return 0;
65211   }
65212   {
65213     try {
65214       result = (float)(darg)->CalculateChildSizeSwigPublic((Dali::Actor const &)*arg2,arg3);
65215     } catch (std::out_of_range& e) {
65216       {
65217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65218       };
65219     } catch (std::exception& e) {
65220       {
65221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65222       };
65223     } catch (Dali::DaliException e) {
65224       {
65225         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65226       };
65227     } catch (...) {
65228       {
65229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65230       };
65231     }
65232   }
65233
65234   jresult = result;
65235   return jresult;
65236 }
65237
65238
65239 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidth(void * jarg1, float jarg2) {
65240   float jresult ;
65241   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65242   float arg2 ;
65243   SwigDirector_ViewImpl *darg = 0;
65244   float result;
65245
65246   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65247   arg2 = (float)jarg2;
65248   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65249   if (!darg) {
65250     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65251     return 0;
65252   }
65253   {
65254     try {
65255       result = (float)(darg)->GetHeightForWidth(arg2);
65256     } catch (std::out_of_range& e) {
65257       {
65258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65259       };
65260     } catch (std::exception& e) {
65261       {
65262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65263       };
65264     } catch (Dali::DaliException e) {
65265       {
65266         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65267       };
65268     } catch (...) {
65269       {
65270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65271       };
65272     }
65273   }
65274
65275   jresult = result;
65276   return jresult;
65277 }
65278
65279
65280 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidthSwigExplicitViewImpl(void * jarg1, float jarg2) {
65281   float jresult ;
65282   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65283   float arg2 ;
65284   SwigDirector_ViewImpl *darg = 0;
65285   float result;
65286
65287   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65288   arg2 = (float)jarg2;
65289   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65290   if (!darg) {
65291     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65292     return 0;
65293   }
65294   {
65295     try {
65296       result = (float)(darg)->GetHeightForWidthSwigPublic(arg2);
65297     } catch (std::out_of_range& e) {
65298       {
65299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65300       };
65301     } catch (std::exception& e) {
65302       {
65303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65304       };
65305     } catch (Dali::DaliException e) {
65306       {
65307         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65308       };
65309     } catch (...) {
65310       {
65311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65312       };
65313     }
65314   }
65315
65316   jresult = result;
65317   return jresult;
65318 }
65319
65320
65321 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeight(void * jarg1, float jarg2) {
65322   float jresult ;
65323   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65324   float arg2 ;
65325   SwigDirector_ViewImpl *darg = 0;
65326   float result;
65327
65328   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65329   arg2 = (float)jarg2;
65330   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65331   if (!darg) {
65332     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65333     return 0;
65334   }
65335   {
65336     try {
65337       result = (float)(darg)->GetWidthForHeight(arg2);
65338     } catch (std::out_of_range& e) {
65339       {
65340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65341       };
65342     } catch (std::exception& e) {
65343       {
65344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65345       };
65346     } catch (Dali::DaliException e) {
65347       {
65348         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65349       };
65350     } catch (...) {
65351       {
65352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65353       };
65354     }
65355   }
65356
65357   jresult = result;
65358   return jresult;
65359 }
65360
65361
65362 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeightSwigExplicitViewImpl(void * jarg1, float jarg2) {
65363   float jresult ;
65364   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65365   float arg2 ;
65366   SwigDirector_ViewImpl *darg = 0;
65367   float result;
65368
65369   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65370   arg2 = (float)jarg2;
65371   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65372   if (!darg) {
65373     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65374     return 0;
65375   }
65376   {
65377     try {
65378       result = (float)(darg)->GetWidthForHeightSwigPublic(arg2);
65379     } catch (std::out_of_range& e) {
65380       {
65381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65382       };
65383     } catch (std::exception& e) {
65384       {
65385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65386       };
65387     } catch (Dali::DaliException e) {
65388       {
65389         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65390       };
65391     } catch (...) {
65392       {
65393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65394       };
65395     }
65396   }
65397
65398   jresult = result;
65399   return jresult;
65400 }
65401
65402
65403 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
65404   unsigned int jresult ;
65405   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65406   Dali::Dimension::Type arg2 ;
65407   SwigDirector_ViewImpl *darg = 0;
65408   bool result;
65409
65410   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65411   arg2 = (Dali::Dimension::Type)jarg2;
65412   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65413   if (!darg) {
65414     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65415     return 0;
65416   }
65417   {
65418     try {
65419       result = (bool)(darg)->RelayoutDependentOnChildren(arg2);
65420     } catch (std::out_of_range& e) {
65421       {
65422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65423       };
65424     } catch (std::exception& e) {
65425       {
65426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65427       };
65428     } catch (Dali::DaliException e) {
65429       {
65430         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65431       };
65432     } catch (...) {
65433       {
65434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65435       };
65436     }
65437   }
65438
65439   jresult = result;
65440   return jresult;
65441 }
65442
65443
65444 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_0(void * jarg1, int jarg2) {
65445   unsigned int jresult ;
65446   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65447   Dali::Dimension::Type arg2 ;
65448   SwigDirector_ViewImpl *darg = 0;
65449   bool result;
65450
65451   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65452   arg2 = (Dali::Dimension::Type)jarg2;
65453   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65454   if (!darg) {
65455     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65456     return 0;
65457   }
65458   {
65459     try {
65460       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic(arg2);
65461     } catch (std::out_of_range& e) {
65462       {
65463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65464       };
65465     } catch (std::exception& e) {
65466       {
65467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65468       };
65469     } catch (Dali::DaliException e) {
65470       {
65471         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65472       };
65473     } catch (...) {
65474       {
65475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65476       };
65477     }
65478   }
65479
65480   jresult = result;
65481   return jresult;
65482 }
65483
65484
65485 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
65486   unsigned int jresult ;
65487   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65488   SwigDirector_ViewImpl *darg = 0;
65489   bool result;
65490
65491   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65492   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65493   if (!darg) {
65494     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65495     return 0;
65496   }
65497   {
65498     try {
65499       result = (bool)(darg)->RelayoutDependentOnChildren();
65500     } catch (std::out_of_range& e) {
65501       {
65502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65503       };
65504     } catch (std::exception& e) {
65505       {
65506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65507       };
65508     } catch (Dali::DaliException e) {
65509       {
65510         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65511       };
65512     } catch (...) {
65513       {
65514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65515       };
65516     }
65517   }
65518
65519   jresult = result;
65520   return jresult;
65521 }
65522
65523
65524 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_1(void * jarg1) {
65525   unsigned int jresult ;
65526   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65527   SwigDirector_ViewImpl *darg = 0;
65528   bool result;
65529
65530   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65531   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65532   if (!darg) {
65533     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65534     return 0;
65535   }
65536   {
65537     try {
65538       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic();
65539     } catch (std::out_of_range& e) {
65540       {
65541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65542       };
65543     } catch (std::exception& e) {
65544       {
65545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65546       };
65547     } catch (Dali::DaliException e) {
65548       {
65549         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65550       };
65551     } catch (...) {
65552       {
65553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65554       };
65555     }
65556   }
65557
65558   jresult = result;
65559   return jresult;
65560 }
65561
65562
65563 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
65564   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65565   Dali::Dimension::Type arg2 ;
65566   SwigDirector_ViewImpl *darg = 0;
65567
65568   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65569   arg2 = (Dali::Dimension::Type)jarg2;
65570   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65571   if (!darg) {
65572     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65573     return;
65574   }
65575   {
65576     try {
65577       (darg)->OnCalculateRelayoutSize(arg2);
65578     } catch (std::out_of_range& e) {
65579       {
65580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65581       };
65582     } catch (std::exception& e) {
65583       {
65584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65585       };
65586     } catch (Dali::DaliException e) {
65587       {
65588         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65589       };
65590     } catch (...) {
65591       {
65592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65593       };
65594     }
65595   }
65596
65597 }
65598
65599
65600 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSizeSwigExplicitViewImpl(void * jarg1, int jarg2) {
65601   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65602   Dali::Dimension::Type arg2 ;
65603   SwigDirector_ViewImpl *darg = 0;
65604
65605   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65606   arg2 = (Dali::Dimension::Type)jarg2;
65607   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65608   if (!darg) {
65609     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65610     return;
65611   }
65612   {
65613     try {
65614       (darg)->OnCalculateRelayoutSizeSwigPublic(arg2);
65615     } catch (std::out_of_range& e) {
65616       {
65617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65618       };
65619     } catch (std::exception& e) {
65620       {
65621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65622       };
65623     } catch (Dali::DaliException e) {
65624       {
65625         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65626       };
65627     } catch (...) {
65628       {
65629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65630       };
65631     }
65632   }
65633
65634 }
65635
65636
65637 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
65638   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65639   float arg2 ;
65640   Dali::Dimension::Type arg3 ;
65641   SwigDirector_ViewImpl *darg = 0;
65642
65643   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65644   arg2 = (float)jarg2;
65645   arg3 = (Dali::Dimension::Type)jarg3;
65646   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65647   if (!darg) {
65648     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65649     return;
65650   }
65651   {
65652     try {
65653       (darg)->OnLayoutNegotiated(arg2,arg3);
65654     } catch (std::out_of_range& e) {
65655       {
65656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65657       };
65658     } catch (std::exception& e) {
65659       {
65660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65661       };
65662     } catch (Dali::DaliException e) {
65663       {
65664         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65665       };
65666     } catch (...) {
65667       {
65668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65669       };
65670     }
65671   }
65672
65673 }
65674
65675
65676 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiatedSwigExplicitViewImpl(void * jarg1, float jarg2, int jarg3) {
65677   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65678   float arg2 ;
65679   Dali::Dimension::Type arg3 ;
65680   SwigDirector_ViewImpl *darg = 0;
65681
65682   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65683   arg2 = (float)jarg2;
65684   arg3 = (Dali::Dimension::Type)jarg3;
65685   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65686   if (!darg) {
65687     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65688     return;
65689   }
65690   {
65691     try {
65692       (darg)->OnLayoutNegotiatedSwigPublic(arg2,arg3);
65693     } catch (std::out_of_range& e) {
65694       {
65695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65696       };
65697     } catch (std::exception& e) {
65698       {
65699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65700       };
65701     } catch (Dali::DaliException e) {
65702       {
65703         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65704       };
65705     } catch (...) {
65706       {
65707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65708       };
65709     }
65710   }
65711
65712 }
65713
65714
65715 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitialize(void * jarg1) {
65716   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65717
65718   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65719   {
65720     try {
65721       (arg1)->OnInitialize();
65722     } catch (std::out_of_range& e) {
65723       {
65724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65725       };
65726     } catch (std::exception& e) {
65727       {
65728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65729       };
65730     } catch (Dali::DaliException e) {
65731       {
65732         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65733       };
65734     } catch (...) {
65735       {
65736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65737       };
65738     }
65739   }
65740
65741 }
65742
65743
65744 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitializeSwigExplicitViewImpl(void * jarg1) {
65745   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65746
65747   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65748   {
65749     try {
65750       (arg1)->Dali::Toolkit::Internal::Control::OnInitialize();
65751     } catch (std::out_of_range& e) {
65752       {
65753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65754       };
65755     } catch (std::exception& e) {
65756       {
65757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65758       };
65759     } catch (Dali::DaliException e) {
65760       {
65761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65762       };
65763     } catch (...) {
65764       {
65765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65766       };
65767     }
65768   }
65769
65770 }
65771
65772
65773 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildAdd(void * jarg1, void * jarg2) {
65774   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65775   Dali::Actor *arg2 = 0 ;
65776
65777   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65778   arg2 = (Dali::Actor *)jarg2;
65779   if (!arg2) {
65780     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
65781     return ;
65782   }
65783   {
65784     try {
65785       (arg1)->OnControlChildAdd(*arg2);
65786     } catch (std::out_of_range& e) {
65787       {
65788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65789       };
65790     } catch (std::exception& e) {
65791       {
65792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65793       };
65794     } catch (Dali::DaliException e) {
65795       {
65796         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65797       };
65798     } catch (...) {
65799       {
65800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65801       };
65802     }
65803   }
65804
65805 }
65806
65807
65808 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
65809   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65810   Dali::Actor *arg2 = 0 ;
65811
65812   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65813   arg2 = (Dali::Actor *)jarg2;
65814   if (!arg2) {
65815     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
65816     return ;
65817   }
65818   {
65819     try {
65820       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildAdd(*arg2);
65821     } catch (std::out_of_range& e) {
65822       {
65823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65824       };
65825     } catch (std::exception& e) {
65826       {
65827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65828       };
65829     } catch (Dali::DaliException e) {
65830       {
65831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65832       };
65833     } catch (...) {
65834       {
65835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65836       };
65837     }
65838   }
65839
65840 }
65841
65842
65843 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildRemove(void * jarg1, void * jarg2) {
65844   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65845   Dali::Actor *arg2 = 0 ;
65846
65847   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65848   arg2 = (Dali::Actor *)jarg2;
65849   if (!arg2) {
65850     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
65851     return ;
65852   }
65853   {
65854     try {
65855       (arg1)->OnControlChildRemove(*arg2);
65856     } catch (std::out_of_range& e) {
65857       {
65858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65859       };
65860     } catch (std::exception& e) {
65861       {
65862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65863       };
65864     } catch (Dali::DaliException e) {
65865       {
65866         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65867       };
65868     } catch (...) {
65869       {
65870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65871       };
65872     }
65873   }
65874
65875 }
65876
65877
65878 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
65879   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65880   Dali::Actor *arg2 = 0 ;
65881
65882   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65883   arg2 = (Dali::Actor *)jarg2;
65884   if (!arg2) {
65885     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
65886     return ;
65887   }
65888   {
65889     try {
65890       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildRemove(*arg2);
65891     } catch (std::out_of_range& e) {
65892       {
65893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65894       };
65895     } catch (std::exception& e) {
65896       {
65897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65898       };
65899     } catch (Dali::DaliException e) {
65900       {
65901         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65902       };
65903     } catch (...) {
65904       {
65905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65906       };
65907     }
65908   }
65909
65910 }
65911
65912
65913 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChange(void * jarg1, void * jarg2, int jarg3) {
65914   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65915   Dali::Toolkit::StyleManager arg2 ;
65916   Dali::StyleChange::Type arg3 ;
65917   Dali::Toolkit::StyleManager *argp2 ;
65918
65919   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65920   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
65921   if (!argp2) {
65922     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
65923     return ;
65924   }
65925   arg2 = *argp2;
65926   arg3 = (Dali::StyleChange::Type)jarg3;
65927   {
65928     try {
65929       (arg1)->OnStyleChange(arg2,arg3);
65930     } catch (std::out_of_range& e) {
65931       {
65932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65933       };
65934     } catch (std::exception& e) {
65935       {
65936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65937       };
65938     } catch (Dali::DaliException e) {
65939       {
65940         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65941       };
65942     } catch (...) {
65943       {
65944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65945       };
65946     }
65947   }
65948
65949 }
65950
65951
65952 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChangeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
65953   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65954   Dali::Toolkit::StyleManager arg2 ;
65955   Dali::StyleChange::Type arg3 ;
65956   Dali::Toolkit::StyleManager *argp2 ;
65957
65958   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65959   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
65960   if (!argp2) {
65961     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
65962     return ;
65963   }
65964   arg2 = *argp2;
65965   arg3 = (Dali::StyleChange::Type)jarg3;
65966   {
65967     try {
65968       (arg1)->Dali::Toolkit::Internal::Control::OnStyleChange(arg2,arg3);
65969     } catch (std::out_of_range& e) {
65970       {
65971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65972       };
65973     } catch (std::exception& e) {
65974       {
65975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65976       };
65977     } catch (Dali::DaliException e) {
65978       {
65979         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65980       };
65981     } catch (...) {
65982       {
65983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65984       };
65985     }
65986   }
65987
65988 }
65989
65990
65991 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivated(void * jarg1) {
65992   unsigned int jresult ;
65993   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65994   bool result;
65995
65996   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65997   {
65998     try {
65999       result = (bool)(arg1)->OnAccessibilityActivated();
66000     } catch (std::out_of_range& e) {
66001       {
66002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66003       };
66004     } catch (std::exception& e) {
66005       {
66006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66007       };
66008     } catch (Dali::DaliException e) {
66009       {
66010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66011       };
66012     } catch (...) {
66013       {
66014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66015       };
66016     }
66017   }
66018
66019   jresult = result;
66020   return jresult;
66021 }
66022
66023
66024 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivatedSwigExplicitViewImpl(void * jarg1) {
66025   unsigned int jresult ;
66026   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66027   bool result;
66028
66029   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66030   {
66031     try {
66032       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
66033     } catch (std::out_of_range& e) {
66034       {
66035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66036       };
66037     } catch (std::exception& e) {
66038       {
66039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66040       };
66041     } catch (Dali::DaliException e) {
66042       {
66043         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66044       };
66045     } catch (...) {
66046       {
66047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66048       };
66049     }
66050   }
66051
66052   jresult = result;
66053   return jresult;
66054 }
66055
66056
66057 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPan(void * jarg1, void * jarg2) {
66058   unsigned int jresult ;
66059   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66060   Dali::PanGesture arg2 ;
66061   Dali::PanGesture *argp2 ;
66062   bool result;
66063
66064   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66065   argp2 = (Dali::PanGesture *)jarg2;
66066   if (!argp2) {
66067     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
66068     return 0;
66069   }
66070   arg2 = *argp2;
66071   {
66072     try {
66073       result = (bool)(arg1)->OnAccessibilityPan(arg2);
66074     } catch (std::out_of_range& e) {
66075       {
66076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66077       };
66078     } catch (std::exception& e) {
66079       {
66080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66081       };
66082     } catch (Dali::DaliException e) {
66083       {
66084         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66085       };
66086     } catch (...) {
66087       {
66088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66089       };
66090     }
66091   }
66092
66093   jresult = result;
66094   return jresult;
66095 }
66096
66097
66098 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66099   unsigned int jresult ;
66100   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66101   Dali::PanGesture arg2 ;
66102   Dali::PanGesture *argp2 ;
66103   bool result;
66104
66105   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66106   argp2 = (Dali::PanGesture *)jarg2;
66107   if (!argp2) {
66108     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
66109     return 0;
66110   }
66111   arg2 = *argp2;
66112   {
66113     try {
66114       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityPan(arg2);
66115     } catch (std::out_of_range& e) {
66116       {
66117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66118       };
66119     } catch (std::exception& e) {
66120       {
66121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66122       };
66123     } catch (Dali::DaliException e) {
66124       {
66125         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66126       };
66127     } catch (...) {
66128       {
66129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66130       };
66131     }
66132   }
66133
66134   jresult = result;
66135   return jresult;
66136 }
66137
66138
66139 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouch(void * jarg1, void * jarg2) {
66140   unsigned int jresult ;
66141   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66142   Dali::TouchEvent *arg2 = 0 ;
66143   bool result;
66144
66145   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66146   arg2 = (Dali::TouchEvent *)jarg2;
66147   if (!arg2) {
66148     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
66149     return 0;
66150   }
66151   {
66152     try {
66153       result = (bool)(arg1)->OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
66154     } catch (std::out_of_range& e) {
66155       {
66156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66157       };
66158     } catch (std::exception& e) {
66159       {
66160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66161       };
66162     } catch (Dali::DaliException e) {
66163       {
66164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66165       };
66166     } catch (...) {
66167       {
66168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66169       };
66170     }
66171   }
66172
66173   jresult = result;
66174   return jresult;
66175 }
66176
66177
66178 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66179   unsigned int jresult ;
66180   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66181   Dali::TouchEvent *arg2 = 0 ;
66182   bool result;
66183
66184   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66185   arg2 = (Dali::TouchEvent *)jarg2;
66186   if (!arg2) {
66187     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
66188     return 0;
66189   }
66190   {
66191     try {
66192       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
66193     } catch (std::out_of_range& e) {
66194       {
66195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66196       };
66197     } catch (std::exception& e) {
66198       {
66199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66200       };
66201     } catch (Dali::DaliException e) {
66202       {
66203         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66204       };
66205     } catch (...) {
66206       {
66207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66208       };
66209     }
66210   }
66211
66212   jresult = result;
66213   return jresult;
66214 }
66215
66216
66217 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChange(void * jarg1, unsigned int jarg2) {
66218   unsigned int jresult ;
66219   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66220   bool arg2 ;
66221   bool result;
66222
66223   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66224   arg2 = jarg2 ? true : false;
66225   {
66226     try {
66227       result = (bool)(arg1)->OnAccessibilityValueChange(arg2);
66228     } catch (std::out_of_range& e) {
66229       {
66230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66231       };
66232     } catch (std::exception& e) {
66233       {
66234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66235       };
66236     } catch (Dali::DaliException e) {
66237       {
66238         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66239       };
66240     } catch (...) {
66241       {
66242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66243       };
66244     }
66245   }
66246
66247   jresult = result;
66248   return jresult;
66249 }
66250
66251
66252 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChangeSwigExplicitViewImpl(void * jarg1, unsigned int jarg2) {
66253   unsigned int jresult ;
66254   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66255   bool arg2 ;
66256   bool result;
66257
66258   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66259   arg2 = jarg2 ? true : false;
66260   {
66261     try {
66262       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(arg2);
66263     } catch (std::out_of_range& e) {
66264       {
66265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66266       };
66267     } catch (std::exception& e) {
66268       {
66269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66270       };
66271     } catch (Dali::DaliException e) {
66272       {
66273         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66274       };
66275     } catch (...) {
66276       {
66277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66278       };
66279     }
66280   }
66281
66282   jresult = result;
66283   return jresult;
66284 }
66285
66286
66287 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoom(void * jarg1) {
66288   unsigned int jresult ;
66289   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66290   bool result;
66291
66292   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66293   {
66294     try {
66295       result = (bool)(arg1)->OnAccessibilityZoom();
66296     } catch (std::out_of_range& e) {
66297       {
66298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66299       };
66300     } catch (std::exception& e) {
66301       {
66302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66303       };
66304     } catch (Dali::DaliException e) {
66305       {
66306         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66307       };
66308     } catch (...) {
66309       {
66310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66311       };
66312     }
66313   }
66314
66315   jresult = result;
66316   return jresult;
66317 }
66318
66319
66320 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoomSwigExplicitViewImpl(void * jarg1) {
66321   unsigned int jresult ;
66322   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66323   bool result;
66324
66325   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66326   {
66327     try {
66328       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
66329     } catch (std::out_of_range& e) {
66330       {
66331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66332       };
66333     } catch (std::exception& e) {
66334       {
66335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66336       };
66337     } catch (Dali::DaliException e) {
66338       {
66339         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66340       };
66341     } catch (...) {
66342       {
66343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66344       };
66345     }
66346   }
66347
66348   jresult = result;
66349   return jresult;
66350 }
66351
66352
66353 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGained(void * jarg1) {
66354   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66355
66356   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66357   {
66358     try {
66359       (arg1)->OnKeyInputFocusGained();
66360     } catch (std::out_of_range& e) {
66361       {
66362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66363       };
66364     } catch (std::exception& e) {
66365       {
66366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66367       };
66368     } catch (Dali::DaliException e) {
66369       {
66370         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66371       };
66372     } catch (...) {
66373       {
66374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66375       };
66376     }
66377   }
66378
66379 }
66380
66381
66382 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGainedSwigExplicitViewImpl(void * jarg1) {
66383   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66384
66385   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66386   {
66387     try {
66388       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
66389     } catch (std::out_of_range& e) {
66390       {
66391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66392       };
66393     } catch (std::exception& e) {
66394       {
66395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66396       };
66397     } catch (Dali::DaliException e) {
66398       {
66399         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66400       };
66401     } catch (...) {
66402       {
66403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66404       };
66405     }
66406   }
66407
66408 }
66409
66410
66411 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLost(void * jarg1) {
66412   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66413
66414   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66415   {
66416     try {
66417       (arg1)->OnKeyInputFocusLost();
66418     } catch (std::out_of_range& e) {
66419       {
66420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66421       };
66422     } catch (std::exception& e) {
66423       {
66424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66425       };
66426     } catch (Dali::DaliException e) {
66427       {
66428         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66429       };
66430     } catch (...) {
66431       {
66432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66433       };
66434     }
66435   }
66436
66437 }
66438
66439
66440 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLostSwigExplicitViewImpl(void * jarg1) {
66441   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66442
66443   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66444   {
66445     try {
66446       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
66447     } catch (std::out_of_range& e) {
66448       {
66449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66450       };
66451     } catch (std::exception& e) {
66452       {
66453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66454       };
66455     } catch (Dali::DaliException e) {
66456       {
66457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66458       };
66459     } catch (...) {
66460       {
66461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66462       };
66463     }
66464   }
66465
66466 }
66467
66468
66469 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActor(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
66470   void * jresult ;
66471   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66472   Dali::Actor arg2 ;
66473   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
66474   bool arg4 ;
66475   Dali::Actor *argp2 ;
66476   Dali::Actor result;
66477
66478   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66479   argp2 = (Dali::Actor *)jarg2;
66480   if (!argp2) {
66481     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66482     return 0;
66483   }
66484   arg2 = *argp2;
66485   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
66486   arg4 = jarg4 ? true : false;
66487   {
66488     try {
66489       result = (arg1)->GetNextKeyboardFocusableActor(arg2,arg3,arg4);
66490     } catch (std::out_of_range& e) {
66491       {
66492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66493       };
66494     } catch (std::exception& e) {
66495       {
66496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66497       };
66498     } catch (Dali::DaliException e) {
66499       {
66500         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66501       };
66502     } catch (...) {
66503       {
66504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66505       };
66506     }
66507   }
66508
66509   jresult = new Dali::Actor((const Dali::Actor &)result);
66510   return jresult;
66511 }
66512
66513
66514 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActorSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
66515   void * jresult ;
66516   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66517   Dali::Actor arg2 ;
66518   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
66519   bool arg4 ;
66520   Dali::Actor *argp2 ;
66521   Dali::Actor result;
66522
66523   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66524   argp2 = (Dali::Actor *)jarg2;
66525   if (!argp2) {
66526     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66527     return 0;
66528   }
66529   arg2 = *argp2;
66530   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
66531   arg4 = jarg4 ? true : false;
66532   {
66533     try {
66534       result = (arg1)->Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(arg2,arg3,arg4);
66535     } catch (std::out_of_range& e) {
66536       {
66537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66538       };
66539     } catch (std::exception& e) {
66540       {
66541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66542       };
66543     } catch (Dali::DaliException e) {
66544       {
66545         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66546       };
66547     } catch (...) {
66548       {
66549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66550       };
66551     }
66552   }
66553
66554   jresult = new Dali::Actor((const Dali::Actor &)result);
66555   return jresult;
66556 }
66557
66558
66559 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommitted(void * jarg1, void * jarg2) {
66560   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66561   Dali::Actor arg2 ;
66562   Dali::Actor *argp2 ;
66563
66564   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66565   argp2 = (Dali::Actor *)jarg2;
66566   if (!argp2) {
66567     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66568     return ;
66569   }
66570   arg2 = *argp2;
66571   {
66572     try {
66573       (arg1)->OnKeyboardFocusChangeCommitted(arg2);
66574     } catch (std::out_of_range& e) {
66575       {
66576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66577       };
66578     } catch (std::exception& e) {
66579       {
66580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66581       };
66582     } catch (Dali::DaliException e) {
66583       {
66584         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66585       };
66586     } catch (...) {
66587       {
66588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66589       };
66590     }
66591   }
66592
66593 }
66594
66595
66596 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommittedSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66597   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66598   Dali::Actor arg2 ;
66599   Dali::Actor *argp2 ;
66600
66601   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66602   argp2 = (Dali::Actor *)jarg2;
66603   if (!argp2) {
66604     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66605     return ;
66606   }
66607   arg2 = *argp2;
66608   {
66609     try {
66610       (arg1)->Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(arg2);
66611     } catch (std::out_of_range& e) {
66612       {
66613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66614       };
66615     } catch (std::exception& e) {
66616       {
66617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66618       };
66619     } catch (Dali::DaliException e) {
66620       {
66621         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66622       };
66623     } catch (...) {
66624       {
66625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66626       };
66627     }
66628   }
66629
66630 }
66631
66632
66633 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnter(void * jarg1) {
66634   unsigned int jresult ;
66635   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66636   bool result;
66637
66638   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66639   {
66640     try {
66641       result = (bool)(arg1)->OnKeyboardEnter();
66642     } catch (std::out_of_range& e) {
66643       {
66644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66645       };
66646     } catch (std::exception& e) {
66647       {
66648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66649       };
66650     } catch (Dali::DaliException e) {
66651       {
66652         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66653       };
66654     } catch (...) {
66655       {
66656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66657       };
66658     }
66659   }
66660
66661   jresult = result;
66662   return jresult;
66663 }
66664
66665
66666 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnterSwigExplicitViewImpl(void * jarg1) {
66667   unsigned int jresult ;
66668   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66669   bool result;
66670
66671   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66672   {
66673     try {
66674       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnKeyboardEnter();
66675     } catch (std::out_of_range& e) {
66676       {
66677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66678       };
66679     } catch (std::exception& e) {
66680       {
66681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66682       };
66683     } catch (Dali::DaliException e) {
66684       {
66685         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66686       };
66687     } catch (...) {
66688       {
66689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66690       };
66691     }
66692   }
66693
66694   jresult = result;
66695   return jresult;
66696 }
66697
66698
66699 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinch(void * jarg1, void * jarg2) {
66700   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66701   Dali::PinchGesture *arg2 = 0 ;
66702
66703   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66704   arg2 = (Dali::PinchGesture *)jarg2;
66705   if (!arg2) {
66706     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
66707     return ;
66708   }
66709   {
66710     try {
66711       (arg1)->OnPinch((Dali::PinchGesture const &)*arg2);
66712     } catch (std::out_of_range& e) {
66713       {
66714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66715       };
66716     } catch (std::exception& e) {
66717       {
66718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66719       };
66720     } catch (Dali::DaliException e) {
66721       {
66722         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66723       };
66724     } catch (...) {
66725       {
66726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66727       };
66728     }
66729   }
66730
66731 }
66732
66733
66734 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66735   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66736   Dali::PinchGesture *arg2 = 0 ;
66737
66738   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66739   arg2 = (Dali::PinchGesture *)jarg2;
66740   if (!arg2) {
66741     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
66742     return ;
66743   }
66744   {
66745     try {
66746       (arg1)->Dali::Toolkit::Internal::Control::OnPinch((Dali::PinchGesture const &)*arg2);
66747     } catch (std::out_of_range& e) {
66748       {
66749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66750       };
66751     } catch (std::exception& e) {
66752       {
66753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66754       };
66755     } catch (Dali::DaliException e) {
66756       {
66757         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66758       };
66759     } catch (...) {
66760       {
66761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66762       };
66763     }
66764   }
66765
66766 }
66767
66768
66769 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPan(void * jarg1, void * jarg2) {
66770   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66771   Dali::PanGesture *arg2 = 0 ;
66772
66773   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66774   arg2 = (Dali::PanGesture *)jarg2;
66775   if (!arg2) {
66776     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
66777     return ;
66778   }
66779   {
66780     try {
66781       (arg1)->OnPan((Dali::PanGesture const &)*arg2);
66782     } catch (std::out_of_range& e) {
66783       {
66784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66785       };
66786     } catch (std::exception& e) {
66787       {
66788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66789       };
66790     } catch (Dali::DaliException e) {
66791       {
66792         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66793       };
66794     } catch (...) {
66795       {
66796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66797       };
66798     }
66799   }
66800
66801 }
66802
66803
66804 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66805   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66806   Dali::PanGesture *arg2 = 0 ;
66807
66808   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66809   arg2 = (Dali::PanGesture *)jarg2;
66810   if (!arg2) {
66811     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
66812     return ;
66813   }
66814   {
66815     try {
66816       (arg1)->Dali::Toolkit::Internal::Control::OnPan((Dali::PanGesture const &)*arg2);
66817     } catch (std::out_of_range& e) {
66818       {
66819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66820       };
66821     } catch (std::exception& e) {
66822       {
66823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66824       };
66825     } catch (Dali::DaliException e) {
66826       {
66827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66828       };
66829     } catch (...) {
66830       {
66831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66832       };
66833     }
66834   }
66835
66836 }
66837
66838
66839 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTap(void * jarg1, void * jarg2) {
66840   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66841   Dali::TapGesture *arg2 = 0 ;
66842
66843   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66844   arg2 = (Dali::TapGesture *)jarg2;
66845   if (!arg2) {
66846     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
66847     return ;
66848   }
66849   {
66850     try {
66851       (arg1)->OnTap((Dali::TapGesture const &)*arg2);
66852     } catch (std::out_of_range& e) {
66853       {
66854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66855       };
66856     } catch (std::exception& e) {
66857       {
66858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66859       };
66860     } catch (Dali::DaliException e) {
66861       {
66862         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66863       };
66864     } catch (...) {
66865       {
66866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66867       };
66868     }
66869   }
66870
66871 }
66872
66873
66874 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTapSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66875   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66876   Dali::TapGesture *arg2 = 0 ;
66877
66878   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66879   arg2 = (Dali::TapGesture *)jarg2;
66880   if (!arg2) {
66881     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
66882     return ;
66883   }
66884   {
66885     try {
66886       (arg1)->Dali::Toolkit::Internal::Control::OnTap((Dali::TapGesture const &)*arg2);
66887     } catch (std::out_of_range& e) {
66888       {
66889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66890       };
66891     } catch (std::exception& e) {
66892       {
66893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66894       };
66895     } catch (Dali::DaliException e) {
66896       {
66897         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66898       };
66899     } catch (...) {
66900       {
66901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66902       };
66903     }
66904   }
66905
66906 }
66907
66908
66909 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPress(void * jarg1, void * jarg2) {
66910   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66911   Dali::LongPressGesture *arg2 = 0 ;
66912
66913   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66914   arg2 = (Dali::LongPressGesture *)jarg2;
66915   if (!arg2) {
66916     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
66917     return ;
66918   }
66919   {
66920     try {
66921       (arg1)->OnLongPress((Dali::LongPressGesture const &)*arg2);
66922     } catch (std::out_of_range& e) {
66923       {
66924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66925       };
66926     } catch (std::exception& e) {
66927       {
66928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66929       };
66930     } catch (Dali::DaliException e) {
66931       {
66932         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66933       };
66934     } catch (...) {
66935       {
66936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66937       };
66938     }
66939   }
66940
66941 }
66942
66943
66944 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPressSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66945   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66946   Dali::LongPressGesture *arg2 = 0 ;
66947
66948   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66949   arg2 = (Dali::LongPressGesture *)jarg2;
66950   if (!arg2) {
66951     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
66952     return ;
66953   }
66954   {
66955     try {
66956       (arg1)->Dali::Toolkit::Internal::Control::OnLongPress((Dali::LongPressGesture const &)*arg2);
66957     } catch (std::out_of_range& e) {
66958       {
66959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66960       };
66961     } catch (std::exception& e) {
66962       {
66963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66964       };
66965     } catch (Dali::DaliException e) {
66966       {
66967         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66968       };
66969     } catch (...) {
66970       {
66971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66972       };
66973     }
66974   }
66975
66976 }
66977
66978
66979 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
66980   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66981   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
66982   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
66983
66984   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66985   arg2 = (Dali::SlotObserver *)jarg2;
66986   arg3 = (Dali::CallbackBase *)jarg3;
66987   {
66988     try {
66989       (arg1)->SignalConnected(arg2,arg3);
66990     } catch (std::out_of_range& e) {
66991       {
66992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66993       };
66994     } catch (std::exception& e) {
66995       {
66996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66997       };
66998     } catch (Dali::DaliException e) {
66999       {
67000         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67001       };
67002     } catch (...) {
67003       {
67004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67005       };
67006     }
67007   }
67008
67009 }
67010
67011
67012 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
67013   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67014   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
67015   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
67016
67017   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67018   arg2 = (Dali::SlotObserver *)jarg2;
67019   arg3 = (Dali::CallbackBase *)jarg3;
67020   {
67021     try {
67022       (arg1)->Dali::Toolkit::Internal::Control::SignalConnected(arg2,arg3);
67023     } catch (std::out_of_range& e) {
67024       {
67025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67026       };
67027     } catch (std::exception& e) {
67028       {
67029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67030       };
67031     } catch (Dali::DaliException e) {
67032       {
67033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67034       };
67035     } catch (...) {
67036       {
67037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67038       };
67039     }
67040   }
67041
67042 }
67043
67044
67045 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
67046   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67047   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
67048   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
67049
67050   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67051   arg2 = (Dali::SlotObserver *)jarg2;
67052   arg3 = (Dali::CallbackBase *)jarg3;
67053   {
67054     try {
67055       (arg1)->SignalDisconnected(arg2,arg3);
67056     } catch (std::out_of_range& e) {
67057       {
67058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67059       };
67060     } catch (std::exception& e) {
67061       {
67062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67063       };
67064     } catch (Dali::DaliException e) {
67065       {
67066         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67067       };
67068     } catch (...) {
67069       {
67070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67071       };
67072     }
67073   }
67074
67075 }
67076
67077
67078 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
67079   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67080   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
67081   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
67082
67083   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67084   arg2 = (Dali::SlotObserver *)jarg2;
67085   arg3 = (Dali::CallbackBase *)jarg3;
67086   {
67087     try {
67088       (arg1)->Dali::Toolkit::Internal::Control::SignalDisconnected(arg2,arg3);
67089     } catch (std::out_of_range& e) {
67090       {
67091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67092       };
67093     } catch (std::exception& e) {
67094       {
67095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67096       };
67097     } catch (Dali::DaliException e) {
67098       {
67099         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67100       };
67101     } catch (...) {
67102       {
67103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67104       };
67105     }
67106   }
67107
67108 }
67109
67110
67111 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) {
67112   Dali::Toolkit::Internal::Control *obj = (Dali::Toolkit::Internal::Control *)objarg;
67113   SwigDirector_ViewImpl *director = dynamic_cast<SwigDirector_ViewImpl *>(obj);
67114   if (director) {
67115     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);
67116   }
67117 }
67118
67119
67120 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation__SWIG_0(void * jarg1) {
67121   void * jresult ;
67122   Dali::Toolkit::Control *arg1 = 0 ;
67123   Dali::Toolkit::Internal::Control *result = 0 ;
67124
67125   arg1 = (Dali::Toolkit::Control *)jarg1;
67126   if (!arg1) {
67127     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
67128     return 0;
67129   }
67130   {
67131     try {
67132       result = (Dali::Toolkit::Internal::Control *) &Dali::Toolkit::Internal::GetImplementation(*arg1);
67133     } catch (std::out_of_range& e) {
67134       {
67135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67136       };
67137     } catch (std::exception& e) {
67138       {
67139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67140       };
67141     } catch (Dali::DaliException e) {
67142       {
67143         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67144       };
67145     } catch (...) {
67146       {
67147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67148       };
67149     }
67150   }
67151
67152   jresult = (void *)result;
67153   return jresult;
67154 }
67155
67156
67157 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_STYLE_NAME_get() {
67158   int jresult ;
67159   int result;
67160
67161   result = (int)Dali::Toolkit::Control::Property::STYLE_NAME;
67162   jresult = (int)result;
67163   return jresult;
67164 }
67165
67166
67167 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_COLOR_get() {
67168   int jresult ;
67169   int result;
67170
67171   result = (int)Dali::Toolkit::Control::Property::BACKGROUND_COLOR;
67172   jresult = (int)result;
67173   return jresult;
67174 }
67175
67176
67177 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_IMAGE_get() {
67178   int jresult ;
67179   int result;
67180
67181   result = (int)Dali::Toolkit::Control::Property::BACKGROUND_IMAGE;
67182   jresult = (int)result;
67183   return jresult;
67184 }
67185
67186
67187 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_KEY_INPUT_FOCUS_get() {
67188   int jresult ;
67189   int result;
67190
67191   result = (int)Dali::Toolkit::Control::Property::KEY_INPUT_FOCUS;
67192   jresult = (int)result;
67193   return jresult;
67194 }
67195
67196
67197 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_get() {
67198   int jresult ;
67199   int result;
67200
67201   result = (int)Dali::Toolkit::Control::Property::BACKGROUND;
67202   jresult = (int)result;
67203   return jresult;
67204 }
67205
67206 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_MARGIN_get() {
67207   int jresult ;
67208   int result;
67209
67210   result = (int)Dali::Toolkit::Control::Property::MARGIN;
67211   jresult = (int)result;
67212   return jresult;
67213 }
67214
67215
67216 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_PADDING_get() {
67217   int jresult ;
67218   int result;
67219
67220   result = (int)Dali::Toolkit::Control::Property::PADDING;
67221   jresult = (int)result;
67222   return jresult;
67223 }
67224
67225 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_Property() {
67226   void * jresult ;
67227   Dali::Toolkit::Control::Property *result = 0 ;
67228
67229   {
67230     try {
67231       result = (Dali::Toolkit::Control::Property *)new Dali::Toolkit::Control::Property();
67232     } catch (std::out_of_range& e) {
67233       {
67234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67235       };
67236     } catch (std::exception& e) {
67237       {
67238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67239       };
67240     } catch (Dali::DaliException e) {
67241       {
67242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67243       };
67244     } catch (...) {
67245       {
67246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67247       };
67248     }
67249   }
67250
67251   jresult = (void *)result;
67252   return jresult;
67253 }
67254
67255
67256 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_Property(void * jarg1) {
67257   Dali::Toolkit::Control::Property *arg1 = (Dali::Toolkit::Control::Property *) 0 ;
67258
67259   arg1 = (Dali::Toolkit::Control::Property *)jarg1;
67260   {
67261     try {
67262       delete arg1;
67263     } catch (std::out_of_range& e) {
67264       {
67265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67266       };
67267     } catch (std::exception& e) {
67268       {
67269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67270       };
67271     } catch (Dali::DaliException e) {
67272       {
67273         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67274       };
67275     } catch (...) {
67276       {
67277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67278       };
67279     }
67280   }
67281
67282 }
67283
67284
67285 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_KeyboardFocus() {
67286   void * jresult ;
67287   Dali::Toolkit::Control::KeyboardFocus *result = 0 ;
67288
67289   {
67290     try {
67291       result = (Dali::Toolkit::Control::KeyboardFocus *)new Dali::Toolkit::Control::KeyboardFocus();
67292     } catch (std::out_of_range& e) {
67293       {
67294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67295       };
67296     } catch (std::exception& e) {
67297       {
67298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67299       };
67300     } catch (Dali::DaliException e) {
67301       {
67302         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67303       };
67304     } catch (...) {
67305       {
67306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67307       };
67308     }
67309   }
67310
67311   jresult = (void *)result;
67312   return jresult;
67313 }
67314
67315
67316 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_KeyboardFocus(void * jarg1) {
67317   Dali::Toolkit::Control::KeyboardFocus *arg1 = (Dali::Toolkit::Control::KeyboardFocus *) 0 ;
67318
67319   arg1 = (Dali::Toolkit::Control::KeyboardFocus *)jarg1;
67320   {
67321     try {
67322       delete arg1;
67323     } catch (std::out_of_range& e) {
67324       {
67325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67326       };
67327     } catch (std::exception& e) {
67328       {
67329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67330       };
67331     } catch (Dali::DaliException e) {
67332       {
67333         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67334       };
67335     } catch (...) {
67336       {
67337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67338       };
67339     }
67340   }
67341
67342 }
67343
67344
67345 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_New() {
67346   void * jresult ;
67347   Dali::Toolkit::Control result;
67348
67349   {
67350     try {
67351       result = Dali::Toolkit::Control::New();
67352     } catch (std::out_of_range& e) {
67353       {
67354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67355       };
67356     } catch (std::exception& e) {
67357       {
67358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67359       };
67360     } catch (Dali::DaliException e) {
67361       {
67362         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67363       };
67364     } catch (...) {
67365       {
67366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67367       };
67368     }
67369   }
67370
67371   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
67372   return jresult;
67373 }
67374
67375
67376 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_0() {
67377   void * jresult ;
67378   Dali::Toolkit::Control *result = 0 ;
67379
67380   {
67381     try {
67382       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control();
67383     } catch (std::out_of_range& e) {
67384       {
67385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67386       };
67387     } catch (std::exception& e) {
67388       {
67389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67390       };
67391     } catch (Dali::DaliException e) {
67392       {
67393         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67394       };
67395     } catch (...) {
67396       {
67397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67398       };
67399     }
67400   }
67401
67402   jresult = (void *)result;
67403   return jresult;
67404 }
67405
67406
67407 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_1(void * jarg1) {
67408   void * jresult ;
67409   Dali::Toolkit::Control *arg1 = 0 ;
67410   Dali::Toolkit::Control *result = 0 ;
67411
67412   arg1 = (Dali::Toolkit::Control *)jarg1;
67413   if (!arg1) {
67414     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
67415     return 0;
67416   }
67417   {
67418     try {
67419       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control((Dali::Toolkit::Control const &)*arg1);
67420     } catch (std::out_of_range& e) {
67421       {
67422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67423       };
67424     } catch (std::exception& e) {
67425       {
67426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67427       };
67428     } catch (Dali::DaliException e) {
67429       {
67430         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67431       };
67432     } catch (...) {
67433       {
67434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67435       };
67436     }
67437   }
67438
67439   jresult = (void *)result;
67440   return jresult;
67441 }
67442
67443
67444 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View(void * jarg1) {
67445   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67446
67447   arg1 = (Dali::Toolkit::Control *)jarg1;
67448   {
67449     try {
67450       delete arg1;
67451     } catch (std::out_of_range& e) {
67452       {
67453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67454       };
67455     } catch (std::exception& e) {
67456       {
67457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67458       };
67459     } catch (Dali::DaliException e) {
67460       {
67461         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67462       };
67463     } catch (...) {
67464       {
67465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67466       };
67467     }
67468   }
67469
67470 }
67471
67472
67473 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_Assign(void * jarg1, void * jarg2) {
67474   void * jresult ;
67475   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67476   Dali::Toolkit::Control *arg2 = 0 ;
67477   Dali::Toolkit::Control *result = 0 ;
67478
67479   arg1 = (Dali::Toolkit::Control *)jarg1;
67480   arg2 = (Dali::Toolkit::Control *)jarg2;
67481   if (!arg2) {
67482     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
67483     return 0;
67484   }
67485   {
67486     try {
67487       result = (Dali::Toolkit::Control *) &(arg1)->operator =((Dali::Toolkit::Control const &)*arg2);
67488     } catch (std::out_of_range& e) {
67489       {
67490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67491       };
67492     } catch (std::exception& e) {
67493       {
67494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67495       };
67496     } catch (Dali::DaliException e) {
67497       {
67498         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67499       };
67500     } catch (...) {
67501       {
67502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67503       };
67504     }
67505   }
67506
67507   jresult = (void *)result;
67508   return jresult;
67509 }
67510
67511
67512 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_DownCast(void * jarg1) {
67513   void * jresult ;
67514   Dali::BaseHandle arg1 ;
67515   Dali::BaseHandle *argp1 ;
67516   Dali::Toolkit::Control result;
67517
67518   argp1 = (Dali::BaseHandle *)jarg1;
67519   if (!argp1) {
67520     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
67521     return 0;
67522   }
67523   arg1 = *argp1;
67524   {
67525     try {
67526       result = Dali::Toolkit::Control::DownCast(arg1);
67527     } catch (std::out_of_range& e) {
67528       {
67529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67530       };
67531     } catch (std::exception& e) {
67532       {
67533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67534       };
67535     } catch (Dali::DaliException e) {
67536       {
67537         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67538       };
67539     } catch (...) {
67540       {
67541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67542       };
67543     }
67544   }
67545
67546   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
67547   return jresult;
67548 }
67549
67550
67551 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetKeyInputFocus(void * jarg1) {
67552   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67553
67554   arg1 = (Dali::Toolkit::Control *)jarg1;
67555   {
67556     try {
67557       (arg1)->SetKeyInputFocus();
67558     } catch (std::out_of_range& e) {
67559       {
67560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67561       };
67562     } catch (std::exception& e) {
67563       {
67564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67565       };
67566     } catch (Dali::DaliException e) {
67567       {
67568         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67569       };
67570     } catch (...) {
67571       {
67572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67573       };
67574     }
67575   }
67576
67577 }
67578
67579
67580 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_View_HasKeyInputFocus(void * jarg1) {
67581   unsigned int jresult ;
67582   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67583   bool result;
67584
67585   arg1 = (Dali::Toolkit::Control *)jarg1;
67586   {
67587     try {
67588       result = (bool)(arg1)->HasKeyInputFocus();
67589     } catch (std::out_of_range& e) {
67590       {
67591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67592       };
67593     } catch (std::exception& e) {
67594       {
67595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67596       };
67597     } catch (Dali::DaliException e) {
67598       {
67599         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67600       };
67601     } catch (...) {
67602       {
67603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67604       };
67605     }
67606   }
67607
67608   jresult = result;
67609   return jresult;
67610 }
67611
67612
67613 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearKeyInputFocus(void * jarg1) {
67614   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67615
67616   arg1 = (Dali::Toolkit::Control *)jarg1;
67617   {
67618     try {
67619       (arg1)->ClearKeyInputFocus();
67620     } catch (std::out_of_range& e) {
67621       {
67622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67623       };
67624     } catch (std::exception& e) {
67625       {
67626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67627       };
67628     } catch (Dali::DaliException e) {
67629       {
67630         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67631       };
67632     } catch (...) {
67633       {
67634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67635       };
67636     }
67637   }
67638
67639 }
67640
67641
67642 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPinchGestureDetector(void * jarg1) {
67643   void * jresult ;
67644   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67645   Dali::PinchGestureDetector result;
67646
67647   arg1 = (Dali::Toolkit::Control *)jarg1;
67648   {
67649     try {
67650       result = ((Dali::Toolkit::Control const *)arg1)->GetPinchGestureDetector();
67651     } catch (std::out_of_range& e) {
67652       {
67653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67654       };
67655     } catch (std::exception& e) {
67656       {
67657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67658       };
67659     } catch (Dali::DaliException e) {
67660       {
67661         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67662       };
67663     } catch (...) {
67664       {
67665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67666       };
67667     }
67668   }
67669
67670   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
67671   return jresult;
67672 }
67673
67674
67675 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPanGestureDetector(void * jarg1) {
67676   void * jresult ;
67677   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67678   Dali::PanGestureDetector result;
67679
67680   arg1 = (Dali::Toolkit::Control *)jarg1;
67681   {
67682     try {
67683       result = ((Dali::Toolkit::Control const *)arg1)->GetPanGestureDetector();
67684     } catch (std::out_of_range& e) {
67685       {
67686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67687       };
67688     } catch (std::exception& e) {
67689       {
67690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67691       };
67692     } catch (Dali::DaliException e) {
67693       {
67694         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67695       };
67696     } catch (...) {
67697       {
67698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67699       };
67700     }
67701   }
67702
67703   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
67704   return jresult;
67705 }
67706
67707
67708 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetTapGestureDetector(void * jarg1) {
67709   void * jresult ;
67710   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67711   Dali::TapGestureDetector result;
67712
67713   arg1 = (Dali::Toolkit::Control *)jarg1;
67714   {
67715     try {
67716       result = ((Dali::Toolkit::Control const *)arg1)->GetTapGestureDetector();
67717     } catch (std::out_of_range& e) {
67718       {
67719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67720       };
67721     } catch (std::exception& e) {
67722       {
67723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67724       };
67725     } catch (Dali::DaliException e) {
67726       {
67727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67728       };
67729     } catch (...) {
67730       {
67731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67732       };
67733     }
67734   }
67735
67736   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
67737   return jresult;
67738 }
67739
67740
67741 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetLongPressGestureDetector(void * jarg1) {
67742   void * jresult ;
67743   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67744   Dali::LongPressGestureDetector result;
67745
67746   arg1 = (Dali::Toolkit::Control *)jarg1;
67747   {
67748     try {
67749       result = ((Dali::Toolkit::Control const *)arg1)->GetLongPressGestureDetector();
67750     } catch (std::out_of_range& e) {
67751       {
67752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67753       };
67754     } catch (std::exception& e) {
67755       {
67756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67757       };
67758     } catch (Dali::DaliException e) {
67759       {
67760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67761       };
67762     } catch (...) {
67763       {
67764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67765       };
67766     }
67767   }
67768
67769   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
67770   return jresult;
67771 }
67772
67773
67774 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetStyleName(void * jarg1, char * jarg2) {
67775   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67776   std::string *arg2 = 0 ;
67777
67778   arg1 = (Dali::Toolkit::Control *)jarg1;
67779   if (!jarg2) {
67780     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
67781     return ;
67782   }
67783   std::string arg2_str(jarg2);
67784   arg2 = &arg2_str;
67785   {
67786     try {
67787       (arg1)->SetStyleName((std::string const &)*arg2);
67788     } catch (std::out_of_range& e) {
67789       {
67790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67791       };
67792     } catch (std::exception& e) {
67793       {
67794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67795       };
67796     } catch (Dali::DaliException e) {
67797       {
67798         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67799       };
67800     } catch (...) {
67801       {
67802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67803       };
67804     }
67805   }
67806
67807
67808   //argout typemap for const std::string&
67809
67810 }
67811
67812
67813 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_View_GetStyleName(void * jarg1) {
67814   char * jresult ;
67815   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67816   std::string *result = 0 ;
67817
67818   arg1 = (Dali::Toolkit::Control *)jarg1;
67819   {
67820     try {
67821       result = (std::string *) &((Dali::Toolkit::Control const *)arg1)->GetStyleName();
67822     } catch (std::out_of_range& e) {
67823       {
67824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67825       };
67826     } catch (std::exception& e) {
67827       {
67828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67829       };
67830     } catch (Dali::DaliException e) {
67831       {
67832         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67833       };
67834     } catch (...) {
67835       {
67836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67837       };
67838     }
67839   }
67840
67841   jresult = SWIG_csharp_string_callback(result->c_str());
67842   return jresult;
67843 }
67844
67845
67846 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundColor(void * jarg1, void * jarg2) {
67847   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67848   Dali::Vector4 *arg2 = 0 ;
67849
67850   arg1 = (Dali::Toolkit::Control *)jarg1;
67851   arg2 = (Dali::Vector4 *)jarg2;
67852   if (!arg2) {
67853     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
67854     return ;
67855   }
67856   {
67857     try {
67858       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
67859     } catch (std::out_of_range& e) {
67860       {
67861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67862       };
67863     } catch (std::exception& e) {
67864       {
67865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67866       };
67867     } catch (Dali::DaliException e) {
67868       {
67869         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67870       };
67871     } catch (...) {
67872       {
67873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67874       };
67875     }
67876   }
67877
67878 }
67879
67880
67881 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetBackgroundColor(void * jarg1) {
67882   void * jresult ;
67883   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67884   Dali::Vector4 result;
67885
67886   arg1 = (Dali::Toolkit::Control *)jarg1;
67887   {
67888     try {
67889       result = ((Dali::Toolkit::Control const *)arg1)->GetBackgroundColor();
67890     } catch (std::out_of_range& e) {
67891       {
67892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67893       };
67894     } catch (std::exception& e) {
67895       {
67896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67897       };
67898     } catch (Dali::DaliException e) {
67899       {
67900         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67901       };
67902     } catch (...) {
67903       {
67904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67905       };
67906     }
67907   }
67908
67909   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
67910   return jresult;
67911 }
67912
67913
67914 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundImage(void * jarg1, void * jarg2) {
67915   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67916   Dali::Image arg2 ;
67917   Dali::Image *argp2 ;
67918
67919   arg1 = (Dali::Toolkit::Control *)jarg1;
67920   argp2 = (Dali::Image *)jarg2;
67921   if (!argp2) {
67922     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
67923     return ;
67924   }
67925   arg2 = *argp2;
67926   {
67927     try {
67928       (arg1)->SetBackgroundImage(arg2);
67929     } catch (std::out_of_range& e) {
67930       {
67931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67932       };
67933     } catch (std::exception& e) {
67934       {
67935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67936       };
67937     } catch (Dali::DaliException e) {
67938       {
67939         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67940       };
67941     } catch (...) {
67942       {
67943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67944       };
67945     }
67946   }
67947
67948 }
67949
67950
67951 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearBackground(void * jarg1) {
67952   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67953
67954   arg1 = (Dali::Toolkit::Control *)jarg1;
67955   {
67956     try {
67957       (arg1)->ClearBackground();
67958     } catch (std::out_of_range& e) {
67959       {
67960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67961       };
67962     } catch (std::exception& e) {
67963       {
67964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67965       };
67966     } catch (Dali::DaliException e) {
67967       {
67968         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67969       };
67970     } catch (...) {
67971       {
67972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67973       };
67974     }
67975   }
67976
67977 }
67978
67979
67980 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyEventSignal(void * jarg1) {
67981   void * jresult ;
67982   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67983   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
67984
67985   arg1 = (Dali::Toolkit::Control *)jarg1;
67986   {
67987     try {
67988       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
67989     } catch (std::out_of_range& e) {
67990       {
67991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67992       };
67993     } catch (std::exception& e) {
67994       {
67995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67996       };
67997     } catch (Dali::DaliException e) {
67998       {
67999         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68000       };
68001     } catch (...) {
68002       {
68003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68004       };
68005     }
68006   }
68007
68008   jresult = (void *)result;
68009   return jresult;
68010 }
68011
68012
68013 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusGainedSignal(void * jarg1) {
68014   void * jresult ;
68015   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68016   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
68017
68018   arg1 = (Dali::Toolkit::Control *)jarg1;
68019   {
68020     try {
68021       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
68022     } catch (std::out_of_range& e) {
68023       {
68024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68025       };
68026     } catch (std::exception& e) {
68027       {
68028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68029       };
68030     } catch (Dali::DaliException e) {
68031       {
68032         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68033       };
68034     } catch (...) {
68035       {
68036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68037       };
68038     }
68039   }
68040
68041   jresult = (void *)result;
68042   return jresult;
68043 }
68044
68045
68046 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusLostSignal(void * jarg1) {
68047   void * jresult ;
68048   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68049   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
68050
68051   arg1 = (Dali::Toolkit::Control *)jarg1;
68052   {
68053     try {
68054       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
68055     } catch (std::out_of_range& e) {
68056       {
68057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68058       };
68059     } catch (std::exception& e) {
68060       {
68061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68062       };
68063     } catch (Dali::DaliException e) {
68064       {
68065         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68066       };
68067     } catch (...) {
68068       {
68069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68070       };
68071     }
68072   }
68073
68074   jresult = (void *)result;
68075   return jresult;
68076 }
68077
68078
68079 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_2(void * jarg1) {
68080   void * jresult ;
68081   Dali::Toolkit::Internal::Control *arg1 = 0 ;
68082   Dali::Toolkit::Control *result = 0 ;
68083
68084   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
68085   if (!arg1) {
68086     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Internal::Control & type is null", 0);
68087     return 0;
68088   }
68089   {
68090     try {
68091       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control(*arg1);
68092     } catch (std::out_of_range& e) {
68093       {
68094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68095       };
68096     } catch (std::exception& e) {
68097       {
68098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68099       };
68100     } catch (Dali::DaliException e) {
68101       {
68102         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68103       };
68104     } catch (...) {
68105       {
68106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68107       };
68108     }
68109   }
68110
68111   jresult = (void *)result;
68112   return jresult;
68113 }
68114
68115 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_GetVisualResourceStatus(void * jarg1, int jarg2)
68116 {
68117   int jresult;
68118   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68119   arg1 = (Dali::Toolkit::Control *)jarg1;
68120
68121   if (!arg1) {
68122     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
68123     return 0;
68124   }
68125
68126   Dali::Property::Index arg2 = 0 ;
68127   arg2 = (Dali::Property::Index)jarg2;
68128
68129   Toolkit::Visual::ResourceStatus result;
68130   {
68131     try {
68132       result = arg1->GetVisualResourceStatus(arg2);
68133     } catch (std::out_of_range& e) {
68134       {
68135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68136       };
68137     } catch (std::exception& e) {
68138       {
68139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68140       };
68141     } catch (...) {
68142       {
68143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68144       };
68145     }
68146   }
68147   jresult = (int)(result);
68148   return jresult;
68149 }
68150
68151 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_CreateTransition(void * jarg1, void * jarg2)
68152 {
68153   void * jresult;
68154   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68155   arg1 = (Dali::Toolkit::Control *)jarg1;
68156
68157   Dali::Toolkit::Internal::Control& controlImpl = Dali::Toolkit::Internal::GetImplementation( *arg1 );
68158
68159   Dali::Toolkit::TransitionData *arg2 = 0 ;
68160   Dali::Animation result;
68161
68162   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
68163   if (!arg2) {
68164     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
68165     return 0;
68166   }
68167   {
68168     try {
68169       result = DevelControl::CreateTransition( controlImpl, (Dali::Toolkit::TransitionData const &)*arg2);
68170     } catch (std::out_of_range& e) {
68171       {
68172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68173       };
68174     } catch (std::exception& e) {
68175       {
68176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68177       };
68178     } catch (Dali::DaliException e) {
68179       {
68180         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68181       };
68182     } catch (...) {
68183       {
68184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68185       };
68186     }
68187   }
68188
68189   jresult = new Dali::Animation((const Dali::Animation &)result);
68190   return jresult;
68191 }
68192
68193 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_DoAction(void * jarg1, int jarg2, int jarg3, void * jarg4 )
68194 {
68195   Dali::Toolkit::Control arg1;
68196   Dali::Toolkit::Control *argp1  = (Dali::Toolkit::Control *)jarg1;
68197
68198   if (!argp1) {
68199     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
68200   }
68201   arg1 = *argp1;
68202
68203   Dali::Property::Index arg2 = 0 ;
68204   arg2 = (Dali::Property::Index)jarg2;
68205
68206   Dali::Property::Index arg3 = 0 ;
68207   arg3 = (Dali::Property::Index)jarg3;
68208
68209   Dali::Property::Value arg4;
68210   arg4 = (Dali::Property::Value *)jarg4;
68211
68212   {
68213     try {
68214       DevelControl::DoAction(arg1, arg2, arg3, arg4);
68215     } catch (std::out_of_range& e) {
68216       {
68217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68218       };
68219     } catch (std::exception& e) {
68220       {
68221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68222       };
68223     } catch (...) {
68224       {
68225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68226       };
68227     }
68228   }
68229
68230
68231 }
68232
68233 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceReadySignal(void * jarg1) {
68234   void * jresult ;
68235   Dali::Toolkit::Control *arg1 = 0 ;
68236   Dali::Toolkit::Control::ResourceReadySignalType *result = 0 ;
68237
68238   arg1 = (Dali::Toolkit::Control *)jarg1;
68239   if (!arg1) {
68240     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
68241     return 0;
68242   }
68243   {
68244     try {
68245       result = (Dali::Toolkit::Control::ResourceReadySignalType *) &arg1->ResourceReadySignal();
68246     } catch (std::out_of_range& e) {
68247       {
68248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68249       };
68250     } catch (std::exception& e) {
68251       {
68252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68253       };
68254     } catch (Dali::DaliException e) {
68255       {
68256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68257       };
68258     } catch (...) {
68259       {
68260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68261       };
68262     }
68263   }
68264
68265   jresult = (void *)result;
68266   return jresult;
68267 }
68268
68269
68270 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsResourceReady(void * jarg1) {
68271   unsigned int jresult ;
68272   Dali::Toolkit::Control *arg1 = 0 ;
68273   bool result;
68274
68275   arg1 = (Dali::Toolkit::Control *)jarg1;
68276   if (!arg1) {
68277     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
68278     return 0;
68279   }
68280   {
68281     try {
68282       result = (bool)arg1->IsResourceReady();
68283     } catch (std::out_of_range& e) {
68284       {
68285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68286       };
68287     } catch (std::exception& e) {
68288       {
68289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68290       };
68291     } catch (Dali::DaliException e) {
68292       {
68293         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68294       };
68295     } catch (...) {
68296       {
68297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68298       };
68299     }
68300   }
68301
68302   jresult = result;
68303   return jresult;
68304 }
68305
68306
68307 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusManager() {
68308   void * jresult ;
68309   Dali::Toolkit::KeyInputFocusManager *result = 0 ;
68310
68311   {
68312     try {
68313       result = (Dali::Toolkit::KeyInputFocusManager *)new Dali::Toolkit::KeyInputFocusManager();
68314     } catch (std::out_of_range& e) {
68315       {
68316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68317       };
68318     } catch (std::exception& e) {
68319       {
68320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68321       };
68322     } catch (Dali::DaliException e) {
68323       {
68324         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68325       };
68326     } catch (...) {
68327       {
68328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68329       };
68330     }
68331   }
68332
68333   jresult = (void *)result;
68334   return jresult;
68335 }
68336
68337
68338 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusManager(void * jarg1) {
68339   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68340
68341   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68342   {
68343     try {
68344       delete arg1;
68345     } catch (std::out_of_range& e) {
68346       {
68347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68348       };
68349     } catch (std::exception& e) {
68350       {
68351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68352       };
68353     } catch (Dali::DaliException e) {
68354       {
68355         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68356       };
68357     } catch (...) {
68358       {
68359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68360       };
68361     }
68362   }
68363
68364 }
68365
68366
68367 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_Get() {
68368   void * jresult ;
68369   Dali::Toolkit::KeyInputFocusManager result;
68370
68371   {
68372     try {
68373       result = Dali::Toolkit::KeyInputFocusManager::Get();
68374     } catch (std::out_of_range& e) {
68375       {
68376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68377       };
68378     } catch (std::exception& e) {
68379       {
68380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68381       };
68382     } catch (Dali::DaliException e) {
68383       {
68384         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68385       };
68386     } catch (...) {
68387       {
68388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68389       };
68390     }
68391   }
68392
68393   jresult = new Dali::Toolkit::KeyInputFocusManager((const Dali::Toolkit::KeyInputFocusManager &)result);
68394   return jresult;
68395 }
68396
68397
68398 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SetFocus(void * jarg1, void * jarg2) {
68399   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68400   Dali::Toolkit::Control arg2 ;
68401   Dali::Toolkit::Control *argp2 ;
68402
68403   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68404   argp2 = (Dali::Toolkit::Control *)jarg2;
68405   if (!argp2) {
68406     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
68407     return ;
68408   }
68409   arg2 = *argp2;
68410   {
68411     try {
68412       (arg1)->SetFocus(arg2);
68413     } catch (std::out_of_range& e) {
68414       {
68415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68416       };
68417     } catch (std::exception& e) {
68418       {
68419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68420       };
68421     } catch (Dali::DaliException e) {
68422       {
68423         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68424       };
68425     } catch (...) {
68426       {
68427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68428       };
68429     }
68430   }
68431
68432 }
68433
68434
68435 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_GetCurrentFocusControl(void * jarg1) {
68436   void * jresult ;
68437   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68438   Dali::Toolkit::Control result;
68439
68440   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68441   {
68442     try {
68443       result = ((Dali::Toolkit::KeyInputFocusManager const *)arg1)->GetCurrentFocusControl();
68444     } catch (std::out_of_range& e) {
68445       {
68446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68447       };
68448     } catch (std::exception& e) {
68449       {
68450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68451       };
68452     } catch (Dali::DaliException e) {
68453       {
68454         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68455       };
68456     } catch (...) {
68457       {
68458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68459       };
68460     }
68461   }
68462
68463   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
68464   return jresult;
68465 }
68466
68467
68468 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_RemoveFocus(void * jarg1, void * jarg2) {
68469   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68470   Dali::Toolkit::Control arg2 ;
68471   Dali::Toolkit::Control *argp2 ;
68472
68473   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68474   argp2 = (Dali::Toolkit::Control *)jarg2;
68475   if (!argp2) {
68476     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
68477     return ;
68478   }
68479   arg2 = *argp2;
68480   {
68481     try {
68482       (arg1)->RemoveFocus(arg2);
68483     } catch (std::out_of_range& e) {
68484       {
68485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68486       };
68487     } catch (std::exception& e) {
68488       {
68489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68490       };
68491     } catch (Dali::DaliException e) {
68492       {
68493         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68494       };
68495     } catch (...) {
68496       {
68497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68498       };
68499     }
68500   }
68501
68502 }
68503
68504
68505 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_KeyInputFocusChangedSignal(void * jarg1) {
68506   void * jresult ;
68507   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68508   Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *result = 0 ;
68509
68510   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68511   {
68512     try {
68513       result = (Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *) &(arg1)->KeyInputFocusChangedSignal();
68514     } catch (std::out_of_range& e) {
68515       {
68516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68517       };
68518     } catch (std::exception& e) {
68519       {
68520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68521       };
68522     } catch (Dali::DaliException e) {
68523       {
68524         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68525       };
68526     } catch (...) {
68527       {
68528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68529       };
68530     }
68531   }
68532
68533   jresult = (void *)result;
68534   return jresult;
68535 }
68536
68537
68538 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_0() {
68539   void * jresult ;
68540   Dali::Toolkit::Alignment::Padding *result = 0 ;
68541
68542   {
68543     try {
68544       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding();
68545     } catch (std::out_of_range& e) {
68546       {
68547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68548       };
68549     } catch (std::exception& e) {
68550       {
68551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68552       };
68553     } catch (Dali::DaliException e) {
68554       {
68555         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68556       };
68557     } catch (...) {
68558       {
68559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68560       };
68561     }
68562   }
68563
68564   jresult = (void *)result;
68565   return jresult;
68566 }
68567
68568
68569 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
68570   void * jresult ;
68571   float arg1 ;
68572   float arg2 ;
68573   float arg3 ;
68574   float arg4 ;
68575   Dali::Toolkit::Alignment::Padding *result = 0 ;
68576
68577   arg1 = (float)jarg1;
68578   arg2 = (float)jarg2;
68579   arg3 = (float)jarg3;
68580   arg4 = (float)jarg4;
68581   {
68582     try {
68583       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding(arg1,arg2,arg3,arg4);
68584     } catch (std::out_of_range& e) {
68585       {
68586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68587       };
68588     } catch (std::exception& e) {
68589       {
68590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68591       };
68592     } catch (Dali::DaliException e) {
68593       {
68594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68595       };
68596     } catch (...) {
68597       {
68598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68599       };
68600     }
68601   }
68602
68603   jresult = (void *)result;
68604   return jresult;
68605 }
68606
68607
68608 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_set(void * jarg1, float jarg2) {
68609   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68610   float arg2 ;
68611
68612   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68613   arg2 = (float)jarg2;
68614   if (arg1) (arg1)->left = arg2;
68615 }
68616
68617
68618 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_get(void * jarg1) {
68619   float jresult ;
68620   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68621   float result;
68622
68623   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68624   result = (float) ((arg1)->left);
68625   jresult = result;
68626   return jresult;
68627 }
68628
68629
68630 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_set(void * jarg1, float jarg2) {
68631   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68632   float arg2 ;
68633
68634   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68635   arg2 = (float)jarg2;
68636   if (arg1) (arg1)->right = arg2;
68637 }
68638
68639
68640 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_get(void * jarg1) {
68641   float jresult ;
68642   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68643   float result;
68644
68645   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68646   result = (float) ((arg1)->right);
68647   jresult = result;
68648   return jresult;
68649 }
68650
68651
68652 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_set(void * jarg1, float jarg2) {
68653   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68654   float arg2 ;
68655
68656   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68657   arg2 = (float)jarg2;
68658   if (arg1) (arg1)->top = arg2;
68659 }
68660
68661
68662 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_get(void * jarg1) {
68663   float jresult ;
68664   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68665   float result;
68666
68667   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68668   result = (float) ((arg1)->top);
68669   jresult = result;
68670   return jresult;
68671 }
68672
68673
68674 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_set(void * jarg1, float jarg2) {
68675   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68676   float arg2 ;
68677
68678   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68679   arg2 = (float)jarg2;
68680   if (arg1) (arg1)->bottom = arg2;
68681 }
68682
68683
68684 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_get(void * jarg1) {
68685   float jresult ;
68686   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68687   float result;
68688
68689   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68690   result = (float) ((arg1)->bottom);
68691   jresult = result;
68692   return jresult;
68693 }
68694
68695
68696 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment_Padding(void * jarg1) {
68697   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68698
68699   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68700   {
68701     try {
68702       delete arg1;
68703     } catch (std::out_of_range& e) {
68704       {
68705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68706       };
68707     } catch (std::exception& e) {
68708       {
68709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68710       };
68711     } catch (Dali::DaliException e) {
68712       {
68713         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68714       };
68715     } catch (...) {
68716       {
68717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68718       };
68719     }
68720   }
68721
68722 }
68723
68724
68725 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_0() {
68726   void * jresult ;
68727   Dali::Toolkit::Alignment *result = 0 ;
68728
68729   {
68730     try {
68731       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment();
68732     } catch (std::out_of_range& e) {
68733       {
68734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68735       };
68736     } catch (std::exception& e) {
68737       {
68738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68739       };
68740     } catch (Dali::DaliException e) {
68741       {
68742         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68743       };
68744     } catch (...) {
68745       {
68746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68747       };
68748     }
68749   }
68750
68751   jresult = (void *)result;
68752   return jresult;
68753 }
68754
68755
68756 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_0(int jarg1, int jarg2) {
68757   void * jresult ;
68758   Dali::Toolkit::Alignment::Type arg1 ;
68759   Dali::Toolkit::Alignment::Type arg2 ;
68760   Dali::Toolkit::Alignment result;
68761
68762   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
68763   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
68764   {
68765     try {
68766       result = Dali::Toolkit::Alignment::New(arg1,arg2);
68767     } catch (std::out_of_range& e) {
68768       {
68769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68770       };
68771     } catch (std::exception& e) {
68772       {
68773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68774       };
68775     } catch (Dali::DaliException e) {
68776       {
68777         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68778       };
68779     } catch (...) {
68780       {
68781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68782       };
68783     }
68784   }
68785
68786   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
68787   return jresult;
68788 }
68789
68790
68791 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_1(int jarg1) {
68792   void * jresult ;
68793   Dali::Toolkit::Alignment::Type arg1 ;
68794   Dali::Toolkit::Alignment result;
68795
68796   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
68797   {
68798     try {
68799       result = Dali::Toolkit::Alignment::New(arg1);
68800     } catch (std::out_of_range& e) {
68801       {
68802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68803       };
68804     } catch (std::exception& e) {
68805       {
68806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68807       };
68808     } catch (Dali::DaliException e) {
68809       {
68810         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68811       };
68812     } catch (...) {
68813       {
68814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68815       };
68816     }
68817   }
68818
68819   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
68820   return jresult;
68821 }
68822
68823
68824 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_2() {
68825   void * jresult ;
68826   Dali::Toolkit::Alignment result;
68827
68828   {
68829     try {
68830       result = Dali::Toolkit::Alignment::New();
68831     } catch (std::out_of_range& e) {
68832       {
68833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68834       };
68835     } catch (std::exception& e) {
68836       {
68837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68838       };
68839     } catch (Dali::DaliException e) {
68840       {
68841         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68842       };
68843     } catch (...) {
68844       {
68845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68846       };
68847     }
68848   }
68849
68850   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
68851   return jresult;
68852 }
68853
68854
68855 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_1(void * jarg1) {
68856   void * jresult ;
68857   Dali::Toolkit::Alignment *arg1 = 0 ;
68858   Dali::Toolkit::Alignment *result = 0 ;
68859
68860   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68861   if (!arg1) {
68862     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
68863     return 0;
68864   }
68865   {
68866     try {
68867       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment((Dali::Toolkit::Alignment const &)*arg1);
68868     } catch (std::out_of_range& e) {
68869       {
68870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68871       };
68872     } catch (std::exception& e) {
68873       {
68874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68875       };
68876     } catch (Dali::DaliException e) {
68877       {
68878         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68879       };
68880     } catch (...) {
68881       {
68882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68883       };
68884     }
68885   }
68886
68887   jresult = (void *)result;
68888   return jresult;
68889 }
68890
68891
68892 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment(void * jarg1) {
68893   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68894
68895   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68896   {
68897     try {
68898       delete arg1;
68899     } catch (std::out_of_range& e) {
68900       {
68901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68902       };
68903     } catch (std::exception& e) {
68904       {
68905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68906       };
68907     } catch (Dali::DaliException e) {
68908       {
68909         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68910       };
68911     } catch (...) {
68912       {
68913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68914       };
68915     }
68916   }
68917
68918 }
68919
68920
68921 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_DownCast(void * jarg1) {
68922   void * jresult ;
68923   Dali::BaseHandle arg1 ;
68924   Dali::BaseHandle *argp1 ;
68925   Dali::Toolkit::Alignment result;
68926
68927   argp1 = (Dali::BaseHandle *)jarg1;
68928   if (!argp1) {
68929     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
68930     return 0;
68931   }
68932   arg1 = *argp1;
68933   {
68934     try {
68935       result = Dali::Toolkit::Alignment::DownCast(arg1);
68936     } catch (std::out_of_range& e) {
68937       {
68938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68939       };
68940     } catch (std::exception& e) {
68941       {
68942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68943       };
68944     } catch (Dali::DaliException e) {
68945       {
68946         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68947       };
68948     } catch (...) {
68949       {
68950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68951       };
68952     }
68953   }
68954
68955   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
68956   return jresult;
68957 }
68958
68959
68960 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetAlignmentType(void * jarg1, int jarg2) {
68961   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68962   Dali::Toolkit::Alignment::Type arg2 ;
68963
68964   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68965   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
68966   {
68967     try {
68968       (arg1)->SetAlignmentType(arg2);
68969     } catch (std::out_of_range& e) {
68970       {
68971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68972       };
68973     } catch (std::exception& e) {
68974       {
68975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68976       };
68977     } catch (Dali::DaliException e) {
68978       {
68979         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68980       };
68981     } catch (...) {
68982       {
68983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68984       };
68985     }
68986   }
68987
68988 }
68989
68990
68991 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetAlignmentType(void * jarg1) {
68992   int jresult ;
68993   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68994   Dali::Toolkit::Alignment::Type result;
68995
68996   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68997   {
68998     try {
68999       result = (Dali::Toolkit::Alignment::Type)((Dali::Toolkit::Alignment const *)arg1)->GetAlignmentType();
69000     } catch (std::out_of_range& e) {
69001       {
69002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69003       };
69004     } catch (std::exception& e) {
69005       {
69006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69007       };
69008     } catch (Dali::DaliException e) {
69009       {
69010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69011       };
69012     } catch (...) {
69013       {
69014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69015       };
69016     }
69017   }
69018
69019   jresult = (int)result;
69020   return jresult;
69021 }
69022
69023
69024 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetScaling(void * jarg1, int jarg2) {
69025   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69026   Dali::Toolkit::Alignment::Scaling arg2 ;
69027
69028   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69029   arg2 = (Dali::Toolkit::Alignment::Scaling)jarg2;
69030   {
69031     try {
69032       (arg1)->SetScaling(arg2);
69033     } catch (std::out_of_range& e) {
69034       {
69035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69036       };
69037     } catch (std::exception& e) {
69038       {
69039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69040       };
69041     } catch (Dali::DaliException e) {
69042       {
69043         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69044       };
69045     } catch (...) {
69046       {
69047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69048       };
69049     }
69050   }
69051
69052 }
69053
69054
69055 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetScaling(void * jarg1) {
69056   int jresult ;
69057   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69058   Dali::Toolkit::Alignment::Scaling result;
69059
69060   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69061   {
69062     try {
69063       result = (Dali::Toolkit::Alignment::Scaling)((Dali::Toolkit::Alignment const *)arg1)->GetScaling();
69064     } catch (std::out_of_range& e) {
69065       {
69066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69067       };
69068     } catch (std::exception& e) {
69069       {
69070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69071       };
69072     } catch (Dali::DaliException e) {
69073       {
69074         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69075       };
69076     } catch (...) {
69077       {
69078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69079       };
69080     }
69081   }
69082
69083   jresult = (int)result;
69084   return jresult;
69085 }
69086
69087
69088 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetPadding(void * jarg1, void * jarg2) {
69089   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69090   Dali::Toolkit::Alignment::Padding *arg2 = 0 ;
69091
69092   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69093   arg2 = (Dali::Toolkit::Alignment::Padding *)jarg2;
69094   if (!arg2) {
69095     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment::Padding const & type is null", 0);
69096     return ;
69097   }
69098   {
69099     try {
69100       (arg1)->SetPadding((Dali::Toolkit::Alignment::Padding const &)*arg2);
69101     } catch (std::out_of_range& e) {
69102       {
69103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69104       };
69105     } catch (std::exception& e) {
69106       {
69107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69108       };
69109     } catch (Dali::DaliException e) {
69110       {
69111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69112       };
69113     } catch (...) {
69114       {
69115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69116       };
69117     }
69118   }
69119
69120 }
69121
69122
69123 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_GetPadding(void * jarg1) {
69124   void * jresult ;
69125   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69126   Dali::Toolkit::Alignment::Padding *result = 0 ;
69127
69128   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69129   {
69130     try {
69131       result = (Dali::Toolkit::Alignment::Padding *) &((Dali::Toolkit::Alignment const *)arg1)->GetPadding();
69132     } catch (std::out_of_range& e) {
69133       {
69134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69135       };
69136     } catch (std::exception& e) {
69137       {
69138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69139       };
69140     } catch (Dali::DaliException e) {
69141       {
69142         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69143       };
69144     } catch (...) {
69145       {
69146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69147       };
69148     }
69149   }
69150
69151   jresult = (void *)result;
69152   return jresult;
69153 }
69154
69155
69156 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_Assign(void * jarg1, void * jarg2) {
69157   void * jresult ;
69158   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69159   Dali::Toolkit::Alignment *arg2 = 0 ;
69160   Dali::Toolkit::Alignment *result = 0 ;
69161
69162   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69163   arg2 = (Dali::Toolkit::Alignment *)jarg2;
69164   if (!arg2) {
69165     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
69166     return 0;
69167   }
69168   {
69169     try {
69170       result = (Dali::Toolkit::Alignment *) &(arg1)->operator =((Dali::Toolkit::Alignment const &)*arg2);
69171     } catch (std::out_of_range& e) {
69172       {
69173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69174       };
69175     } catch (std::exception& e) {
69176       {
69177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69178       };
69179     } catch (Dali::DaliException e) {
69180       {
69181         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69182       };
69183     } catch (...) {
69184       {
69185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69186       };
69187     }
69188   }
69189
69190   jresult = (void *)result;
69191   return jresult;
69192 }
69193
69194
69195 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_DISABLED_get() {
69196   int jresult ;
69197   int result;
69198
69199   result = (int)Dali::Toolkit::Button::Property::DISABLED;
69200   jresult = (int)result;
69201   return jresult;
69202 }
69203
69204
69205 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_AUTO_REPEATING_get() {
69206   int jresult ;
69207   int result;
69208
69209   result = (int)Dali::Toolkit::Button::Property::AUTO_REPEATING;
69210   jresult = (int)result;
69211   return jresult;
69212 }
69213
69214
69215 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_INITIAL_AUTO_REPEATING_DELAY_get() {
69216   int jresult ;
69217   int result;
69218
69219   result = (int)Dali::Toolkit::Button::Property::INITIAL_AUTO_REPEATING_DELAY;
69220   jresult = (int)result;
69221   return jresult;
69222 }
69223
69224
69225 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_NEXT_AUTO_REPEATING_DELAY_get() {
69226   int jresult ;
69227   int result;
69228
69229   result = (int)Dali::Toolkit::Button::Property::NEXT_AUTO_REPEATING_DELAY;
69230   jresult = (int)result;
69231   return jresult;
69232 }
69233
69234
69235 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_TOGGLABLE_get() {
69236   int jresult ;
69237   int result;
69238
69239   result = (int)Dali::Toolkit::Button::Property::TOGGLABLE;
69240   jresult = (int)result;
69241   return jresult;
69242 }
69243
69244
69245 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_get() {
69246   int jresult ;
69247   int result;
69248
69249   result = (int)Dali::Toolkit::Button::Property::SELECTED;
69250   jresult = (int)result;
69251   return jresult;
69252 }
69253
69254
69255 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_UNSELECTED_COLOR_get() {
69256   int jresult ;
69257   int result;
69258
69259   result = (int)Dali::Toolkit::Button::Property::UNSELECTED_COLOR;
69260   jresult = (int)result;
69261   return jresult;
69262 }
69263
69264
69265 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_COLOR_get() {
69266   int jresult ;
69267   int result;
69268
69269   result = (int)Dali::Toolkit::Button::Property::SELECTED_COLOR;
69270   jresult = (int)result;
69271   return jresult;
69272 }
69273
69274
69275 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_get() {
69276   int jresult ;
69277   int result;
69278
69279   result = (int)Dali::Toolkit::Button::Property::LABEL;
69280   jresult = (int)result;
69281   return jresult;
69282 }
69283
69284
69285 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_TEXT_get() {
69286   int jresult ;
69287   int result;
69288
69289   result = (int)Dali::Toolkit::Button::Property::LABEL_TEXT;
69290   jresult = (int)result;
69291   return jresult;
69292 }
69293
69294
69295 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button_Property() {
69296   void * jresult ;
69297   Dali::Toolkit::Button::Property *result = 0 ;
69298
69299   {
69300     try {
69301       result = (Dali::Toolkit::Button::Property *)new Dali::Toolkit::Button::Property();
69302     } catch (std::out_of_range& e) {
69303       {
69304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69305       };
69306     } catch (std::exception& e) {
69307       {
69308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69309       };
69310     } catch (Dali::DaliException e) {
69311       {
69312         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69313       };
69314     } catch (...) {
69315       {
69316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69317       };
69318     }
69319   }
69320
69321   jresult = (void *)result;
69322   return jresult;
69323 }
69324
69325
69326 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button_Property(void * jarg1) {
69327   Dali::Toolkit::Button::Property *arg1 = (Dali::Toolkit::Button::Property *) 0 ;
69328
69329   arg1 = (Dali::Toolkit::Button::Property *)jarg1;
69330   {
69331     try {
69332       delete arg1;
69333     } catch (std::out_of_range& e) {
69334       {
69335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69336       };
69337     } catch (std::exception& e) {
69338       {
69339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69340       };
69341     } catch (Dali::DaliException e) {
69342       {
69343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69344       };
69345     } catch (...) {
69346       {
69347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69348       };
69349     }
69350   }
69351
69352 }
69353
69354
69355 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_0() {
69356   void * jresult ;
69357   Dali::Toolkit::Button *result = 0 ;
69358
69359   {
69360     try {
69361       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button();
69362     } catch (std::out_of_range& e) {
69363       {
69364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69365       };
69366     } catch (std::exception& e) {
69367       {
69368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69369       };
69370     } catch (Dali::DaliException e) {
69371       {
69372         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69373       };
69374     } catch (...) {
69375       {
69376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69377       };
69378     }
69379   }
69380
69381   jresult = (void *)result;
69382   return jresult;
69383 }
69384
69385
69386 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_1(void * jarg1) {
69387   void * jresult ;
69388   Dali::Toolkit::Button *arg1 = 0 ;
69389   Dali::Toolkit::Button *result = 0 ;
69390
69391   arg1 = (Dali::Toolkit::Button *)jarg1;
69392   if (!arg1) {
69393     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
69394     return 0;
69395   }
69396   {
69397     try {
69398       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button((Dali::Toolkit::Button const &)*arg1);
69399     } catch (std::out_of_range& e) {
69400       {
69401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69402       };
69403     } catch (std::exception& e) {
69404       {
69405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69406       };
69407     } catch (Dali::DaliException e) {
69408       {
69409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69410       };
69411     } catch (...) {
69412       {
69413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69414       };
69415     }
69416   }
69417
69418   jresult = (void *)result;
69419   return jresult;
69420 }
69421
69422
69423 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_Assign(void * jarg1, void * jarg2) {
69424   void * jresult ;
69425   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69426   Dali::Toolkit::Button *arg2 = 0 ;
69427   Dali::Toolkit::Button *result = 0 ;
69428
69429   arg1 = (Dali::Toolkit::Button *)jarg1;
69430   arg2 = (Dali::Toolkit::Button *)jarg2;
69431   if (!arg2) {
69432     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
69433     return 0;
69434   }
69435   {
69436     try {
69437       result = (Dali::Toolkit::Button *) &(arg1)->operator =((Dali::Toolkit::Button const &)*arg2);
69438     } catch (std::out_of_range& e) {
69439       {
69440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69441       };
69442     } catch (std::exception& e) {
69443       {
69444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69445       };
69446     } catch (Dali::DaliException e) {
69447       {
69448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69449       };
69450     } catch (...) {
69451       {
69452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69453       };
69454     }
69455   }
69456
69457   jresult = (void *)result;
69458   return jresult;
69459 }
69460
69461
69462 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_DownCast(void * jarg1) {
69463   void * jresult ;
69464   Dali::BaseHandle arg1 ;
69465   Dali::BaseHandle *argp1 ;
69466   Dali::Toolkit::Button result;
69467
69468   argp1 = (Dali::BaseHandle *)jarg1;
69469   if (!argp1) {
69470     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
69471     return 0;
69472   }
69473   arg1 = *argp1;
69474   {
69475     try {
69476       result = Dali::Toolkit::Button::DownCast(arg1);
69477     } catch (std::out_of_range& e) {
69478       {
69479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69480       };
69481     } catch (std::exception& e) {
69482       {
69483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69484       };
69485     } catch (Dali::DaliException e) {
69486       {
69487         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69488       };
69489     } catch (...) {
69490       {
69491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69492       };
69493     }
69494   }
69495
69496   jresult = new Dali::Toolkit::Button((const Dali::Toolkit::Button &)result);
69497   return jresult;
69498 }
69499
69500
69501 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button(void * jarg1) {
69502   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69503
69504   arg1 = (Dali::Toolkit::Button *)jarg1;
69505   {
69506     try {
69507       delete arg1;
69508     } catch (std::out_of_range& e) {
69509       {
69510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69511       };
69512     } catch (std::exception& e) {
69513       {
69514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69515       };
69516     } catch (Dali::DaliException e) {
69517       {
69518         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69519       };
69520     } catch (...) {
69521       {
69522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69523       };
69524     }
69525   }
69526
69527 }
69528
69529
69530 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsDisabled(void * jarg1) {
69531   unsigned int jresult ;
69532   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69533   bool result;
69534
69535   arg1 = (Dali::Toolkit::Button *)jarg1;
69536   {
69537     try {
69538       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsDisabled();
69539     } catch (std::out_of_range& e) {
69540       {
69541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69542       };
69543     } catch (std::exception& e) {
69544       {
69545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69546       };
69547     } catch (Dali::DaliException e) {
69548       {
69549         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69550       };
69551     } catch (...) {
69552       {
69553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69554       };
69555     }
69556   }
69557
69558   jresult = result;
69559   return jresult;
69560 }
69561
69562
69563 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsAutoRepeating(void * jarg1) {
69564   unsigned int jresult ;
69565   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69566   bool result;
69567
69568   arg1 = (Dali::Toolkit::Button *)jarg1;
69569   {
69570     try {
69571       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsAutoRepeating();
69572     } catch (std::out_of_range& e) {
69573       {
69574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69575       };
69576     } catch (std::exception& e) {
69577       {
69578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69579       };
69580     } catch (Dali::DaliException e) {
69581       {
69582         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69583       };
69584     } catch (...) {
69585       {
69586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69587       };
69588     }
69589   }
69590
69591   jresult = result;
69592   return jresult;
69593 }
69594
69595
69596 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetInitialAutoRepeatingDelay(void * jarg1) {
69597   float jresult ;
69598   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69599   float result;
69600
69601   arg1 = (Dali::Toolkit::Button *)jarg1;
69602   {
69603     try {
69604       result = (float)((Dali::Toolkit::Button const *)arg1)->GetInitialAutoRepeatingDelay();
69605     } catch (std::out_of_range& e) {
69606       {
69607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69608       };
69609     } catch (std::exception& e) {
69610       {
69611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69612       };
69613     } catch (Dali::DaliException e) {
69614       {
69615         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69616       };
69617     } catch (...) {
69618       {
69619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69620       };
69621     }
69622   }
69623
69624   jresult = result;
69625   return jresult;
69626 }
69627
69628
69629 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetNextAutoRepeatingDelay(void * jarg1) {
69630   float jresult ;
69631   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69632   float result;
69633
69634   arg1 = (Dali::Toolkit::Button *)jarg1;
69635   {
69636     try {
69637       result = (float)((Dali::Toolkit::Button const *)arg1)->GetNextAutoRepeatingDelay();
69638     } catch (std::out_of_range& e) {
69639       {
69640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69641       };
69642     } catch (std::exception& e) {
69643       {
69644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69645       };
69646     } catch (Dali::DaliException e) {
69647       {
69648         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69649       };
69650     } catch (...) {
69651       {
69652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69653       };
69654     }
69655   }
69656
69657   jresult = result;
69658   return jresult;
69659 }
69660
69661
69662 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsTogglableButton(void * jarg1) {
69663   unsigned int jresult ;
69664   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69665   bool result;
69666
69667   arg1 = (Dali::Toolkit::Button *)jarg1;
69668   {
69669     try {
69670       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsTogglableButton();
69671     } catch (std::out_of_range& e) {
69672       {
69673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69674       };
69675     } catch (std::exception& e) {
69676       {
69677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69678       };
69679     } catch (Dali::DaliException e) {
69680       {
69681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69682       };
69683     } catch (...) {
69684       {
69685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69686       };
69687     }
69688   }
69689
69690   jresult = result;
69691   return jresult;
69692 }
69693
69694
69695 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsSelected(void * jarg1) {
69696   unsigned int jresult ;
69697   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69698   bool result;
69699
69700   arg1 = (Dali::Toolkit::Button *)jarg1;
69701   {
69702     try {
69703       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsSelected();
69704     } catch (std::out_of_range& e) {
69705       {
69706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69707       };
69708     } catch (std::exception& e) {
69709       {
69710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69711       };
69712     } catch (Dali::DaliException e) {
69713       {
69714         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69715       };
69716     } catch (...) {
69717       {
69718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69719       };
69720     }
69721   }
69722
69723   jresult = result;
69724   return jresult;
69725 }
69726
69727
69728 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetAnimationTime(void * jarg1) {
69729   float jresult ;
69730   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69731   float result;
69732
69733   arg1 = (Dali::Toolkit::Button *)jarg1;
69734   {
69735     try {
69736       result = (float)((Dali::Toolkit::Button const *)arg1)->GetAnimationTime();
69737     } catch (std::out_of_range& e) {
69738       {
69739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69740       };
69741     } catch (std::exception& e) {
69742       {
69743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69744       };
69745     } catch (Dali::DaliException e) {
69746       {
69747         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69748       };
69749     } catch (...) {
69750       {
69751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69752       };
69753     }
69754   }
69755
69756   jresult = result;
69757   return jresult;
69758 }
69759
69760
69761 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Button_GetLabelText(void * jarg1) {
69762   char * jresult ;
69763   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69764   std::string result;
69765
69766   arg1 = (Dali::Toolkit::Button *)jarg1;
69767   {
69768     try {
69769       result = ((Dali::Toolkit::Button const *)arg1)->GetLabelText();
69770     } catch (std::out_of_range& e) {
69771       {
69772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69773       };
69774     } catch (std::exception& e) {
69775       {
69776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69777       };
69778     } catch (Dali::DaliException e) {
69779       {
69780         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69781       };
69782     } catch (...) {
69783       {
69784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69785       };
69786     }
69787   }
69788
69789   jresult = SWIG_csharp_string_callback((&result)->c_str());
69790   return jresult;
69791 }
69792
69793
69794 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetLabel(void * jarg1, void * jarg2) {
69795   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69796   Dali::Actor arg2 ;
69797   Dali::Actor *argp2 ;
69798
69799   arg1 = (Dali::Toolkit::Button *)jarg1;
69800   argp2 = (Dali::Actor *)jarg2;
69801   if (!argp2) {
69802     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
69803     return ;
69804   }
69805   arg2 = *argp2;
69806   {
69807     try {
69808       (arg1)->SetLabel(arg2);
69809     } catch (std::out_of_range& e) {
69810       {
69811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69812       };
69813     } catch (std::exception& e) {
69814       {
69815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69816       };
69817     } catch (Dali::DaliException e) {
69818       {
69819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69820       };
69821     } catch (...) {
69822       {
69823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69824       };
69825     }
69826   }
69827
69828 }
69829
69830
69831 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetButtonImage(void * jarg1, void * jarg2) {
69832   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69833   Dali::Image arg2 ;
69834   Dali::Image *argp2 ;
69835
69836   arg1 = (Dali::Toolkit::Button *)jarg1;
69837   argp2 = (Dali::Image *)jarg2;
69838   if (!argp2) {
69839     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
69840     return ;
69841   }
69842   arg2 = *argp2;
69843   {
69844     try {
69845       (arg1)->SetButtonImage(arg2);
69846     } catch (std::out_of_range& e) {
69847       {
69848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69849       };
69850     } catch (std::exception& e) {
69851       {
69852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69853       };
69854     } catch (Dali::DaliException e) {
69855       {
69856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69857       };
69858     } catch (...) {
69859       {
69860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69861       };
69862     }
69863   }
69864
69865 }
69866
69867
69868 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetSelectedImage(void * jarg1, void * jarg2) {
69869   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69870   Dali::Image arg2 ;
69871   Dali::Image *argp2 ;
69872
69873   arg1 = (Dali::Toolkit::Button *)jarg1;
69874   argp2 = (Dali::Image *)jarg2;
69875   if (!argp2) {
69876     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
69877     return ;
69878   }
69879   arg2 = *argp2;
69880   {
69881     try {
69882       (arg1)->SetSelectedImage(arg2);
69883     } catch (std::out_of_range& e) {
69884       {
69885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69886       };
69887     } catch (std::exception& e) {
69888       {
69889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69890       };
69891     } catch (Dali::DaliException e) {
69892       {
69893         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69894       };
69895     } catch (...) {
69896       {
69897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69898       };
69899     }
69900   }
69901
69902 }
69903
69904
69905 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_GetButtonImage(void * jarg1) {
69906   void * jresult ;
69907   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69908   Dali::Actor result;
69909
69910   arg1 = (Dali::Toolkit::Button *)jarg1;
69911   {
69912     try {
69913       result = ((Dali::Toolkit::Button const *)arg1)->GetButtonImage();
69914     } catch (std::out_of_range& e) {
69915       {
69916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69917       };
69918     } catch (std::exception& e) {
69919       {
69920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69921       };
69922     } catch (Dali::DaliException e) {
69923       {
69924         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69925       };
69926     } catch (...) {
69927       {
69928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69929       };
69930     }
69931   }
69932
69933   jresult = new Dali::Actor((const Dali::Actor &)result);
69934   return jresult;
69935 }
69936
69937
69938 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_GetSelectedImage(void * jarg1) {
69939   void * jresult ;
69940   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69941   Dali::Actor result;
69942
69943   arg1 = (Dali::Toolkit::Button *)jarg1;
69944   {
69945     try {
69946       result = ((Dali::Toolkit::Button const *)arg1)->GetSelectedImage();
69947     } catch (std::out_of_range& e) {
69948       {
69949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69950       };
69951     } catch (std::exception& e) {
69952       {
69953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69954       };
69955     } catch (Dali::DaliException e) {
69956       {
69957         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69958       };
69959     } catch (...) {
69960       {
69961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69962       };
69963     }
69964   }
69965
69966   jresult = new Dali::Actor((const Dali::Actor &)result);
69967   return jresult;
69968 }
69969
69970
69971 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_PressedSignal(void * jarg1) {
69972   void * jresult ;
69973   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69974   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
69975
69976   arg1 = (Dali::Toolkit::Button *)jarg1;
69977   {
69978     try {
69979       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->PressedSignal();
69980     } catch (std::out_of_range& e) {
69981       {
69982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69983       };
69984     } catch (std::exception& e) {
69985       {
69986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69987       };
69988     } catch (Dali::DaliException e) {
69989       {
69990         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69991       };
69992     } catch (...) {
69993       {
69994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69995       };
69996     }
69997   }
69998
69999   jresult = (void *)result;
70000   return jresult;
70001 }
70002
70003
70004 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ReleasedSignal(void * jarg1) {
70005   void * jresult ;
70006   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70007   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
70008
70009   arg1 = (Dali::Toolkit::Button *)jarg1;
70010   {
70011     try {
70012       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ReleasedSignal();
70013     } catch (std::out_of_range& e) {
70014       {
70015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70016       };
70017     } catch (std::exception& e) {
70018       {
70019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70020       };
70021     } catch (Dali::DaliException e) {
70022       {
70023         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70024       };
70025     } catch (...) {
70026       {
70027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70028       };
70029     }
70030   }
70031
70032   jresult = (void *)result;
70033   return jresult;
70034 }
70035
70036
70037 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ClickedSignal(void * jarg1) {
70038   void * jresult ;
70039   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70040   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
70041
70042   arg1 = (Dali::Toolkit::Button *)jarg1;
70043   {
70044     try {
70045       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ClickedSignal();
70046     } catch (std::out_of_range& e) {
70047       {
70048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70049       };
70050     } catch (std::exception& e) {
70051       {
70052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70053       };
70054     } catch (Dali::DaliException e) {
70055       {
70056         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70057       };
70058     } catch (...) {
70059       {
70060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70061       };
70062     }
70063   }
70064
70065   jresult = (void *)result;
70066   return jresult;
70067 }
70068
70069
70070 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_StateChangedSignal(void * jarg1) {
70071   void * jresult ;
70072   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70073   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
70074
70075   arg1 = (Dali::Toolkit::Button *)jarg1;
70076   {
70077     try {
70078       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->StateChangedSignal();
70079     } catch (std::out_of_range& e) {
70080       {
70081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70082       };
70083     } catch (std::exception& e) {
70084       {
70085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70086       };
70087     } catch (Dali::DaliException e) {
70088       {
70089         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70090       };
70091     } catch (...) {
70092       {
70093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70094       };
70095     }
70096   }
70097
70098   jresult = (void *)result;
70099   return jresult;
70100 }
70101
70102
70103 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_0() {
70104   void * jresult ;
70105   Dali::Toolkit::CheckBoxButton *result = 0 ;
70106
70107   {
70108     try {
70109       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton();
70110     } catch (std::out_of_range& e) {
70111       {
70112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70113       };
70114     } catch (std::exception& e) {
70115       {
70116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70117       };
70118     } catch (Dali::DaliException e) {
70119       {
70120         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70121       };
70122     } catch (...) {
70123       {
70124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70125       };
70126     }
70127   }
70128
70129   jresult = (void *)result;
70130   return jresult;
70131 }
70132
70133
70134 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_1(void * jarg1) {
70135   void * jresult ;
70136   Dali::Toolkit::CheckBoxButton *arg1 = 0 ;
70137   Dali::Toolkit::CheckBoxButton *result = 0 ;
70138
70139   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
70140   if (!arg1) {
70141     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
70142     return 0;
70143   }
70144   {
70145     try {
70146       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton((Dali::Toolkit::CheckBoxButton const &)*arg1);
70147     } catch (std::out_of_range& e) {
70148       {
70149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70150       };
70151     } catch (std::exception& e) {
70152       {
70153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70154       };
70155     } catch (Dali::DaliException e) {
70156       {
70157         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70158       };
70159     } catch (...) {
70160       {
70161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70162       };
70163     }
70164   }
70165
70166   jresult = (void *)result;
70167   return jresult;
70168 }
70169
70170
70171 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_Assign(void * jarg1, void * jarg2) {
70172   void * jresult ;
70173   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
70174   Dali::Toolkit::CheckBoxButton *arg2 = 0 ;
70175   Dali::Toolkit::CheckBoxButton *result = 0 ;
70176
70177   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
70178   arg2 = (Dali::Toolkit::CheckBoxButton *)jarg2;
70179   if (!arg2) {
70180     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
70181     return 0;
70182   }
70183   {
70184     try {
70185       result = (Dali::Toolkit::CheckBoxButton *) &(arg1)->operator =((Dali::Toolkit::CheckBoxButton const &)*arg2);
70186     } catch (std::out_of_range& e) {
70187       {
70188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70189       };
70190     } catch (std::exception& e) {
70191       {
70192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70193       };
70194     } catch (Dali::DaliException e) {
70195       {
70196         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70197       };
70198     } catch (...) {
70199       {
70200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70201       };
70202     }
70203   }
70204
70205   jresult = (void *)result;
70206   return jresult;
70207 }
70208
70209
70210 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CheckBoxButton(void * jarg1) {
70211   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
70212
70213   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
70214   {
70215     try {
70216       delete arg1;
70217     } catch (std::out_of_range& e) {
70218       {
70219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70220       };
70221     } catch (std::exception& e) {
70222       {
70223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70224       };
70225     } catch (Dali::DaliException e) {
70226       {
70227         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70228       };
70229     } catch (...) {
70230       {
70231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70232       };
70233     }
70234   }
70235
70236 }
70237
70238
70239 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_New() {
70240   void * jresult ;
70241   Dali::Toolkit::CheckBoxButton result;
70242
70243   {
70244     try {
70245       result = Dali::Toolkit::CheckBoxButton::New();
70246     } catch (std::out_of_range& e) {
70247       {
70248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70249       };
70250     } catch (std::exception& e) {
70251       {
70252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70253       };
70254     } catch (Dali::DaliException e) {
70255       {
70256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70257       };
70258     } catch (...) {
70259       {
70260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70261       };
70262     }
70263   }
70264
70265   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
70266   return jresult;
70267 }
70268
70269
70270 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_DownCast(void * jarg1) {
70271   void * jresult ;
70272   Dali::BaseHandle arg1 ;
70273   Dali::BaseHandle *argp1 ;
70274   Dali::Toolkit::CheckBoxButton result;
70275
70276   argp1 = (Dali::BaseHandle *)jarg1;
70277   if (!argp1) {
70278     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
70279     return 0;
70280   }
70281   arg1 = *argp1;
70282   {
70283     try {
70284       result = Dali::Toolkit::CheckBoxButton::DownCast(arg1);
70285     } catch (std::out_of_range& e) {
70286       {
70287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70288       };
70289     } catch (std::exception& e) {
70290       {
70291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70292       };
70293     } catch (Dali::DaliException e) {
70294       {
70295         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70296       };
70297     } catch (...) {
70298       {
70299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70300       };
70301     }
70302   }
70303
70304   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
70305   return jresult;
70306 }
70307
70308
70309 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_UNSELECTED_ICON_get() {
70310   int jresult ;
70311   int result;
70312
70313   result = (int)Dali::Toolkit::PushButton::Property::UNSELECTED_ICON;
70314   jresult = (int)result;
70315   return jresult;
70316 }
70317
70318
70319 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_SELECTED_ICON_get() {
70320   int jresult ;
70321   int result;
70322
70323   result = (int)Dali::Toolkit::PushButton::Property::SELECTED_ICON;
70324   jresult = (int)result;
70325   return jresult;
70326 }
70327
70328
70329 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_ALIGNMENT_get() {
70330   int jresult ;
70331   int result;
70332
70333   result = (int)Dali::Toolkit::PushButton::Property::ICON_ALIGNMENT;
70334   jresult = (int)result;
70335   return jresult;
70336 }
70337
70338
70339 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_LABEL_PADDING_get() {
70340   int jresult ;
70341   int result;
70342
70343   result = (int)Dali::Toolkit::PushButton::Property::LABEL_PADDING;
70344   jresult = (int)result;
70345   return jresult;
70346 }
70347
70348
70349 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_PADDING_get() {
70350   int jresult ;
70351   int result;
70352
70353   result = (int)Dali::Toolkit::PushButton::Property::ICON_PADDING;
70354   jresult = (int)result;
70355   return jresult;
70356 }
70357
70358
70359 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton_Property() {
70360   void * jresult ;
70361   Dali::Toolkit::PushButton::Property *result = 0 ;
70362
70363   {
70364     try {
70365       result = (Dali::Toolkit::PushButton::Property *)new Dali::Toolkit::PushButton::Property();
70366     } catch (std::out_of_range& e) {
70367       {
70368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70369       };
70370     } catch (std::exception& e) {
70371       {
70372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70373       };
70374     } catch (Dali::DaliException e) {
70375       {
70376         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70377       };
70378     } catch (...) {
70379       {
70380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70381       };
70382     }
70383   }
70384
70385   jresult = (void *)result;
70386   return jresult;
70387 }
70388
70389
70390 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton_Property(void * jarg1) {
70391   Dali::Toolkit::PushButton::Property *arg1 = (Dali::Toolkit::PushButton::Property *) 0 ;
70392
70393   arg1 = (Dali::Toolkit::PushButton::Property *)jarg1;
70394   {
70395     try {
70396       delete arg1;
70397     } catch (std::out_of_range& e) {
70398       {
70399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70400       };
70401     } catch (std::exception& e) {
70402       {
70403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70404       };
70405     } catch (Dali::DaliException e) {
70406       {
70407         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70408       };
70409     } catch (...) {
70410       {
70411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70412       };
70413     }
70414   }
70415
70416 }
70417
70418
70419 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_0() {
70420   void * jresult ;
70421   Dali::Toolkit::PushButton *result = 0 ;
70422
70423   {
70424     try {
70425       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton();
70426     } catch (std::out_of_range& e) {
70427       {
70428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70429       };
70430     } catch (std::exception& e) {
70431       {
70432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70433       };
70434     } catch (Dali::DaliException e) {
70435       {
70436         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70437       };
70438     } catch (...) {
70439       {
70440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70441       };
70442     }
70443   }
70444
70445   jresult = (void *)result;
70446   return jresult;
70447 }
70448
70449
70450 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_1(void * jarg1) {
70451   void * jresult ;
70452   Dali::Toolkit::PushButton *arg1 = 0 ;
70453   Dali::Toolkit::PushButton *result = 0 ;
70454
70455   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70456   if (!arg1) {
70457     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
70458     return 0;
70459   }
70460   {
70461     try {
70462       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton((Dali::Toolkit::PushButton const &)*arg1);
70463     } catch (std::out_of_range& e) {
70464       {
70465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70466       };
70467     } catch (std::exception& e) {
70468       {
70469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70470       };
70471     } catch (Dali::DaliException e) {
70472       {
70473         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70474       };
70475     } catch (...) {
70476       {
70477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70478       };
70479     }
70480   }
70481
70482   jresult = (void *)result;
70483   return jresult;
70484 }
70485
70486
70487 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_Assign(void * jarg1, void * jarg2) {
70488   void * jresult ;
70489   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70490   Dali::Toolkit::PushButton *arg2 = 0 ;
70491   Dali::Toolkit::PushButton *result = 0 ;
70492
70493   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70494   arg2 = (Dali::Toolkit::PushButton *)jarg2;
70495   if (!arg2) {
70496     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
70497     return 0;
70498   }
70499   {
70500     try {
70501       result = (Dali::Toolkit::PushButton *) &(arg1)->operator =((Dali::Toolkit::PushButton const &)*arg2);
70502     } catch (std::out_of_range& e) {
70503       {
70504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70505       };
70506     } catch (std::exception& e) {
70507       {
70508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70509       };
70510     } catch (Dali::DaliException e) {
70511       {
70512         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70513       };
70514     } catch (...) {
70515       {
70516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70517       };
70518     }
70519   }
70520
70521   jresult = (void *)result;
70522   return jresult;
70523 }
70524
70525
70526 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton(void * jarg1) {
70527   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70528
70529   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70530   {
70531     try {
70532       delete arg1;
70533     } catch (std::out_of_range& e) {
70534       {
70535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70536       };
70537     } catch (std::exception& e) {
70538       {
70539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70540       };
70541     } catch (Dali::DaliException e) {
70542       {
70543         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70544       };
70545     } catch (...) {
70546       {
70547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70548       };
70549     }
70550   }
70551
70552 }
70553
70554
70555 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_New() {
70556   void * jresult ;
70557   Dali::Toolkit::PushButton result;
70558
70559   {
70560     try {
70561       result = Dali::Toolkit::PushButton::New();
70562     } catch (std::out_of_range& e) {
70563       {
70564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70565       };
70566     } catch (std::exception& e) {
70567       {
70568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70569       };
70570     } catch (Dali::DaliException e) {
70571       {
70572         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70573       };
70574     } catch (...) {
70575       {
70576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70577       };
70578     }
70579   }
70580
70581   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
70582   return jresult;
70583 }
70584
70585
70586 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_DownCast(void * jarg1) {
70587   void * jresult ;
70588   Dali::BaseHandle arg1 ;
70589   Dali::BaseHandle *argp1 ;
70590   Dali::Toolkit::PushButton result;
70591
70592   argp1 = (Dali::BaseHandle *)jarg1;
70593   if (!argp1) {
70594     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
70595     return 0;
70596   }
70597   arg1 = *argp1;
70598   {
70599     try {
70600       result = Dali::Toolkit::PushButton::DownCast(arg1);
70601     } catch (std::out_of_range& e) {
70602       {
70603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70604       };
70605     } catch (std::exception& e) {
70606       {
70607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70608       };
70609     } catch (Dali::DaliException e) {
70610       {
70611         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70612       };
70613     } catch (...) {
70614       {
70615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70616       };
70617     }
70618   }
70619
70620   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
70621   return jresult;
70622 }
70623
70624
70625 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetButtonImage__SWIG_0_0(void * jarg1, void * jarg2) {
70626   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70627   Dali::Image arg2 ;
70628   Dali::Image *argp2 ;
70629
70630   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70631   argp2 = (Dali::Image *)jarg2;
70632   if (!argp2) {
70633     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
70634     return ;
70635   }
70636   arg2 = *argp2;
70637   {
70638     try {
70639       (arg1)->SetButtonImage(arg2);
70640     } catch (std::out_of_range& e) {
70641       {
70642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70643       };
70644     } catch (std::exception& e) {
70645       {
70646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70647       };
70648     } catch (Dali::DaliException e) {
70649       {
70650         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70651       };
70652     } catch (...) {
70653       {
70654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70655       };
70656     }
70657   }
70658
70659 }
70660
70661
70662 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetButtonImage__SWIG_1(void * jarg1, void * jarg2) {
70663   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70664   Dali::Actor arg2 ;
70665   Dali::Actor *argp2 ;
70666
70667   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70668   argp2 = (Dali::Actor *)jarg2;
70669   if (!argp2) {
70670     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70671     return ;
70672   }
70673   arg2 = *argp2;
70674   {
70675     try {
70676       (arg1)->SetButtonImage(arg2);
70677     } catch (std::out_of_range& e) {
70678       {
70679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70680       };
70681     } catch (std::exception& e) {
70682       {
70683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70684       };
70685     } catch (Dali::DaliException e) {
70686       {
70687         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70688       };
70689     } catch (...) {
70690       {
70691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70692       };
70693     }
70694   }
70695
70696 }
70697
70698
70699 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetBackgroundImage(void * jarg1, void * jarg2) {
70700   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70701   Dali::Actor arg2 ;
70702   Dali::Actor *argp2 ;
70703
70704   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70705   argp2 = (Dali::Actor *)jarg2;
70706   if (!argp2) {
70707     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70708     return ;
70709   }
70710   arg2 = *argp2;
70711   {
70712     try {
70713       (arg1)->SetBackgroundImage(arg2);
70714     } catch (std::out_of_range& e) {
70715       {
70716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70717       };
70718     } catch (std::exception& e) {
70719       {
70720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70721       };
70722     } catch (Dali::DaliException e) {
70723       {
70724         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70725       };
70726     } catch (...) {
70727       {
70728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70729       };
70730     }
70731   }
70732
70733 }
70734
70735
70736 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedImage__SWIG_0_0(void * jarg1, void * jarg2) {
70737   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70738   Dali::Image arg2 ;
70739   Dali::Image *argp2 ;
70740
70741   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70742   argp2 = (Dali::Image *)jarg2;
70743   if (!argp2) {
70744     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
70745     return ;
70746   }
70747   arg2 = *argp2;
70748   {
70749     try {
70750       (arg1)->SetSelectedImage(arg2);
70751     } catch (std::out_of_range& e) {
70752       {
70753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70754       };
70755     } catch (std::exception& e) {
70756       {
70757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70758       };
70759     } catch (Dali::DaliException e) {
70760       {
70761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70762       };
70763     } catch (...) {
70764       {
70765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70766       };
70767     }
70768   }
70769
70770 }
70771
70772
70773 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedImage__SWIG_1(void * jarg1, void * jarg2) {
70774   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70775   Dali::Actor arg2 ;
70776   Dali::Actor *argp2 ;
70777
70778   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70779   argp2 = (Dali::Actor *)jarg2;
70780   if (!argp2) {
70781     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70782     return ;
70783   }
70784   arg2 = *argp2;
70785   {
70786     try {
70787       (arg1)->SetSelectedImage(arg2);
70788     } catch (std::out_of_range& e) {
70789       {
70790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70791       };
70792     } catch (std::exception& e) {
70793       {
70794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70795       };
70796     } catch (Dali::DaliException e) {
70797       {
70798         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70799       };
70800     } catch (...) {
70801       {
70802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70803       };
70804     }
70805   }
70806
70807 }
70808
70809
70810 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedBackgroundImage(void * jarg1, void * jarg2) {
70811   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70812   Dali::Actor arg2 ;
70813   Dali::Actor *argp2 ;
70814
70815   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70816   argp2 = (Dali::Actor *)jarg2;
70817   if (!argp2) {
70818     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70819     return ;
70820   }
70821   arg2 = *argp2;
70822   {
70823     try {
70824       (arg1)->SetSelectedBackgroundImage(arg2);
70825     } catch (std::out_of_range& e) {
70826       {
70827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70828       };
70829     } catch (std::exception& e) {
70830       {
70831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70832       };
70833     } catch (Dali::DaliException e) {
70834       {
70835         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70836       };
70837     } catch (...) {
70838       {
70839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70840       };
70841     }
70842   }
70843
70844 }
70845
70846
70847 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledBackgroundImage(void * jarg1, void * jarg2) {
70848   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70849   Dali::Actor arg2 ;
70850   Dali::Actor *argp2 ;
70851
70852   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70853   argp2 = (Dali::Actor *)jarg2;
70854   if (!argp2) {
70855     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70856     return ;
70857   }
70858   arg2 = *argp2;
70859   {
70860     try {
70861       (arg1)->SetDisabledBackgroundImage(arg2);
70862     } catch (std::out_of_range& e) {
70863       {
70864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70865       };
70866     } catch (std::exception& e) {
70867       {
70868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70869       };
70870     } catch (Dali::DaliException e) {
70871       {
70872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70873       };
70874     } catch (...) {
70875       {
70876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70877       };
70878     }
70879   }
70880
70881 }
70882
70883
70884 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledImage(void * jarg1, void * jarg2) {
70885   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70886   Dali::Actor arg2 ;
70887   Dali::Actor *argp2 ;
70888
70889   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70890   argp2 = (Dali::Actor *)jarg2;
70891   if (!argp2) {
70892     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70893     return ;
70894   }
70895   arg2 = *argp2;
70896   {
70897     try {
70898       (arg1)->SetDisabledImage(arg2);
70899     } catch (std::out_of_range& e) {
70900       {
70901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70902       };
70903     } catch (std::exception& e) {
70904       {
70905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70906       };
70907     } catch (Dali::DaliException e) {
70908       {
70909         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70910       };
70911     } catch (...) {
70912       {
70913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70914       };
70915     }
70916   }
70917
70918 }
70919
70920
70921 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledSelectedImage(void * jarg1, void * jarg2) {
70922   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70923   Dali::Actor arg2 ;
70924   Dali::Actor *argp2 ;
70925
70926   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70927   argp2 = (Dali::Actor *)jarg2;
70928   if (!argp2) {
70929     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70930     return ;
70931   }
70932   arg2 = *argp2;
70933   {
70934     try {
70935       (arg1)->SetDisabledSelectedImage(arg2);
70936     } catch (std::out_of_range& e) {
70937       {
70938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70939       };
70940     } catch (std::exception& e) {
70941       {
70942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70943       };
70944     } catch (Dali::DaliException e) {
70945       {
70946         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70947       };
70948     } catch (...) {
70949       {
70950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70951       };
70952     }
70953   }
70954
70955 }
70956
70957
70958 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_0() {
70959   void * jresult ;
70960   Dali::Toolkit::RadioButton *result = 0 ;
70961
70962   {
70963     try {
70964       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton();
70965     } catch (std::out_of_range& e) {
70966       {
70967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70968       };
70969     } catch (std::exception& e) {
70970       {
70971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70972       };
70973     } catch (Dali::DaliException e) {
70974       {
70975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70976       };
70977     } catch (...) {
70978       {
70979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70980       };
70981     }
70982   }
70983
70984   jresult = (void *)result;
70985   return jresult;
70986 }
70987
70988
70989 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_1(void * jarg1) {
70990   void * jresult ;
70991   Dali::Toolkit::RadioButton *arg1 = 0 ;
70992   Dali::Toolkit::RadioButton *result = 0 ;
70993
70994   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
70995   if (!arg1) {
70996     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
70997     return 0;
70998   }
70999   {
71000     try {
71001       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton((Dali::Toolkit::RadioButton const &)*arg1);
71002     } catch (std::out_of_range& e) {
71003       {
71004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71005       };
71006     } catch (std::exception& e) {
71007       {
71008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71009       };
71010     } catch (Dali::DaliException e) {
71011       {
71012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71013       };
71014     } catch (...) {
71015       {
71016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71017       };
71018     }
71019   }
71020
71021   jresult = (void *)result;
71022   return jresult;
71023 }
71024
71025
71026 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_Assign(void * jarg1, void * jarg2) {
71027   void * jresult ;
71028   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
71029   Dali::Toolkit::RadioButton *arg2 = 0 ;
71030   Dali::Toolkit::RadioButton *result = 0 ;
71031
71032   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
71033   arg2 = (Dali::Toolkit::RadioButton *)jarg2;
71034   if (!arg2) {
71035     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
71036     return 0;
71037   }
71038   {
71039     try {
71040       result = (Dali::Toolkit::RadioButton *) &(arg1)->operator =((Dali::Toolkit::RadioButton const &)*arg2);
71041     } catch (std::out_of_range& e) {
71042       {
71043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71044       };
71045     } catch (std::exception& e) {
71046       {
71047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71048       };
71049     } catch (Dali::DaliException e) {
71050       {
71051         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71052       };
71053     } catch (...) {
71054       {
71055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71056       };
71057     }
71058   }
71059
71060   jresult = (void *)result;
71061   return jresult;
71062 }
71063
71064
71065 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RadioButton(void * jarg1) {
71066   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
71067
71068   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
71069   {
71070     try {
71071       delete arg1;
71072     } catch (std::out_of_range& e) {
71073       {
71074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71075       };
71076     } catch (std::exception& e) {
71077       {
71078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71079       };
71080     } catch (Dali::DaliException e) {
71081       {
71082         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71083       };
71084     } catch (...) {
71085       {
71086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71087       };
71088     }
71089   }
71090
71091 }
71092
71093
71094 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_0() {
71095   void * jresult ;
71096   Dali::Toolkit::RadioButton result;
71097
71098   {
71099     try {
71100       result = Dali::Toolkit::RadioButton::New();
71101     } catch (std::out_of_range& e) {
71102       {
71103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71104       };
71105     } catch (std::exception& e) {
71106       {
71107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71108       };
71109     } catch (Dali::DaliException e) {
71110       {
71111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71112       };
71113     } catch (...) {
71114       {
71115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71116       };
71117     }
71118   }
71119
71120   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
71121   return jresult;
71122 }
71123
71124
71125 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_1(char * jarg1) {
71126   void * jresult ;
71127   std::string *arg1 = 0 ;
71128   Dali::Toolkit::RadioButton result;
71129
71130   if (!jarg1) {
71131     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
71132     return 0;
71133   }
71134   std::string arg1_str(jarg1);
71135   arg1 = &arg1_str;
71136   {
71137     try {
71138       result = Dali::Toolkit::RadioButton::New((std::string const &)*arg1);
71139     } catch (std::out_of_range& e) {
71140       {
71141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71142       };
71143     } catch (std::exception& e) {
71144       {
71145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71146       };
71147     } catch (Dali::DaliException e) {
71148       {
71149         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71150       };
71151     } catch (...) {
71152       {
71153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71154       };
71155     }
71156   }
71157
71158   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
71159
71160   //argout typemap for const std::string&
71161
71162   return jresult;
71163 }
71164
71165
71166 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_DownCast(void * jarg1) {
71167   void * jresult ;
71168   Dali::BaseHandle arg1 ;
71169   Dali::BaseHandle *argp1 ;
71170   Dali::Toolkit::RadioButton result;
71171
71172   argp1 = (Dali::BaseHandle *)jarg1;
71173   if (!argp1) {
71174     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
71175     return 0;
71176   }
71177   arg1 = *argp1;
71178   {
71179     try {
71180       result = Dali::Toolkit::RadioButton::DownCast(arg1);
71181     } catch (std::out_of_range& e) {
71182       {
71183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71184       };
71185     } catch (std::exception& e) {
71186       {
71187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71188       };
71189     } catch (Dali::DaliException e) {
71190       {
71191         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71192       };
71193     } catch (...) {
71194       {
71195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71196       };
71197     }
71198   }
71199
71200   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
71201   return jresult;
71202 }
71203
71204
71205 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_CONTENT_DIRECTION_get() {
71206   int jresult ;
71207   int result;
71208
71209   result = (int)Dali::Toolkit::FlexContainer::Property::CONTENT_DIRECTION;
71210   jresult = (int)result;
71211   return jresult;
71212 }
71213
71214
71215 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_DIRECTION_get() {
71216   int jresult ;
71217   int result;
71218
71219   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_DIRECTION;
71220   jresult = (int)result;
71221   return jresult;
71222 }
71223
71224
71225 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_WRAP_get() {
71226   int jresult ;
71227   int result;
71228
71229   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_WRAP;
71230   jresult = (int)result;
71231   return jresult;
71232 }
71233
71234
71235 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_JUSTIFY_CONTENT_get() {
71236   int jresult ;
71237   int result;
71238
71239   result = (int)Dali::Toolkit::FlexContainer::Property::JUSTIFY_CONTENT;
71240   jresult = (int)result;
71241   return jresult;
71242 }
71243
71244
71245 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_ITEMS_get() {
71246   int jresult ;
71247   int result;
71248
71249   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_ITEMS;
71250   jresult = (int)result;
71251   return jresult;
71252 }
71253
71254
71255 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_CONTENT_get() {
71256   int jresult ;
71257   int result;
71258
71259   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_CONTENT;
71260   jresult = (int)result;
71261   return jresult;
71262 }
71263
71264
71265 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_Property() {
71266   void * jresult ;
71267   Dali::Toolkit::FlexContainer::Property *result = 0 ;
71268
71269   {
71270     try {
71271       result = (Dali::Toolkit::FlexContainer::Property *)new Dali::Toolkit::FlexContainer::Property();
71272     } catch (std::out_of_range& e) {
71273       {
71274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71275       };
71276     } catch (std::exception& e) {
71277       {
71278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71279       };
71280     } catch (Dali::DaliException e) {
71281       {
71282         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71283       };
71284     } catch (...) {
71285       {
71286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71287       };
71288     }
71289   }
71290
71291   jresult = (void *)result;
71292   return jresult;
71293 }
71294
71295
71296 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_Property(void * jarg1) {
71297   Dali::Toolkit::FlexContainer::Property *arg1 = (Dali::Toolkit::FlexContainer::Property *) 0 ;
71298
71299   arg1 = (Dali::Toolkit::FlexContainer::Property *)jarg1;
71300   {
71301     try {
71302       delete arg1;
71303     } catch (std::out_of_range& e) {
71304       {
71305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71306       };
71307     } catch (std::exception& e) {
71308       {
71309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71310       };
71311     } catch (Dali::DaliException e) {
71312       {
71313         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71314       };
71315     } catch (...) {
71316       {
71317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71318       };
71319     }
71320   }
71321
71322 }
71323
71324
71325 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_get() {
71326   int jresult ;
71327   int result;
71328
71329   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX;
71330   jresult = (int)result;
71331   return jresult;
71332 }
71333
71334
71335 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_ALIGN_SELF_get() {
71336   int jresult ;
71337   int result;
71338
71339   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::ALIGN_SELF;
71340   jresult = (int)result;
71341   return jresult;
71342 }
71343
71344
71345 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_MARGIN_get() {
71346   int jresult ;
71347   int result;
71348
71349   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX_MARGIN;
71350   jresult = (int)result;
71351   return jresult;
71352 }
71353
71354
71355 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_ChildProperty() {
71356   void * jresult ;
71357   Dali::Toolkit::FlexContainer::ChildProperty *result = 0 ;
71358
71359   {
71360     try {
71361       result = (Dali::Toolkit::FlexContainer::ChildProperty *)new Dali::Toolkit::FlexContainer::ChildProperty();
71362     } catch (std::out_of_range& e) {
71363       {
71364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71365       };
71366     } catch (std::exception& e) {
71367       {
71368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71369       };
71370     } catch (Dali::DaliException e) {
71371       {
71372         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71373       };
71374     } catch (...) {
71375       {
71376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71377       };
71378     }
71379   }
71380
71381   jresult = (void *)result;
71382   return jresult;
71383 }
71384
71385
71386 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_ChildProperty(void * jarg1) {
71387   Dali::Toolkit::FlexContainer::ChildProperty *arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *) 0 ;
71388
71389   arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *)jarg1;
71390   {
71391     try {
71392       delete arg1;
71393     } catch (std::out_of_range& e) {
71394       {
71395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71396       };
71397     } catch (std::exception& e) {
71398       {
71399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71400       };
71401     } catch (Dali::DaliException e) {
71402       {
71403         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71404       };
71405     } catch (...) {
71406       {
71407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71408       };
71409     }
71410   }
71411
71412 }
71413
71414
71415 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_0() {
71416   void * jresult ;
71417   Dali::Toolkit::FlexContainer *result = 0 ;
71418
71419   {
71420     try {
71421       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer();
71422     } catch (std::out_of_range& e) {
71423       {
71424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71425       };
71426     } catch (std::exception& e) {
71427       {
71428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71429       };
71430     } catch (Dali::DaliException e) {
71431       {
71432         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71433       };
71434     } catch (...) {
71435       {
71436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71437       };
71438     }
71439   }
71440
71441   jresult = (void *)result;
71442   return jresult;
71443 }
71444
71445
71446 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_1(void * jarg1) {
71447   void * jresult ;
71448   Dali::Toolkit::FlexContainer *arg1 = 0 ;
71449   Dali::Toolkit::FlexContainer *result = 0 ;
71450
71451   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
71452   if (!arg1) {
71453     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
71454     return 0;
71455   }
71456   {
71457     try {
71458       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer((Dali::Toolkit::FlexContainer const &)*arg1);
71459     } catch (std::out_of_range& e) {
71460       {
71461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71462       };
71463     } catch (std::exception& e) {
71464       {
71465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71466       };
71467     } catch (Dali::DaliException e) {
71468       {
71469         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71470       };
71471     } catch (...) {
71472       {
71473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71474       };
71475     }
71476   }
71477
71478   jresult = (void *)result;
71479   return jresult;
71480 }
71481
71482
71483 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_Assign(void * jarg1, void * jarg2) {
71484   void * jresult ;
71485   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
71486   Dali::Toolkit::FlexContainer *arg2 = 0 ;
71487   Dali::Toolkit::FlexContainer *result = 0 ;
71488
71489   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
71490   arg2 = (Dali::Toolkit::FlexContainer *)jarg2;
71491   if (!arg2) {
71492     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
71493     return 0;
71494   }
71495   {
71496     try {
71497       result = (Dali::Toolkit::FlexContainer *) &(arg1)->operator =((Dali::Toolkit::FlexContainer const &)*arg2);
71498     } catch (std::out_of_range& e) {
71499       {
71500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71501       };
71502     } catch (std::exception& e) {
71503       {
71504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71505       };
71506     } catch (Dali::DaliException e) {
71507       {
71508         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71509       };
71510     } catch (...) {
71511       {
71512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71513       };
71514     }
71515   }
71516
71517   jresult = (void *)result;
71518   return jresult;
71519 }
71520
71521
71522 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer(void * jarg1) {
71523   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
71524
71525   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
71526   {
71527     try {
71528       delete arg1;
71529     } catch (std::out_of_range& e) {
71530       {
71531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71532       };
71533     } catch (std::exception& e) {
71534       {
71535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71536       };
71537     } catch (Dali::DaliException e) {
71538       {
71539         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71540       };
71541     } catch (...) {
71542       {
71543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71544       };
71545     }
71546   }
71547
71548 }
71549
71550
71551 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_New() {
71552   void * jresult ;
71553   Dali::Toolkit::FlexContainer result;
71554
71555   {
71556     try {
71557       result = Dali::Toolkit::FlexContainer::New();
71558     } catch (std::out_of_range& e) {
71559       {
71560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71561       };
71562     } catch (std::exception& e) {
71563       {
71564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71565       };
71566     } catch (Dali::DaliException e) {
71567       {
71568         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71569       };
71570     } catch (...) {
71571       {
71572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71573       };
71574     }
71575   }
71576
71577   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
71578   return jresult;
71579 }
71580
71581
71582 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_DownCast(void * jarg1) {
71583   void * jresult ;
71584   Dali::BaseHandle arg1 ;
71585   Dali::BaseHandle *argp1 ;
71586   Dali::Toolkit::FlexContainer result;
71587
71588   argp1 = (Dali::BaseHandle *)jarg1;
71589   if (!argp1) {
71590     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
71591     return 0;
71592   }
71593   arg1 = *argp1;
71594   {
71595     try {
71596       result = Dali::Toolkit::FlexContainer::DownCast(arg1);
71597     } catch (std::out_of_range& e) {
71598       {
71599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71600       };
71601     } catch (std::exception& e) {
71602       {
71603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71604       };
71605     } catch (Dali::DaliException e) {
71606       {
71607         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71608       };
71609     } catch (...) {
71610       {
71611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71612       };
71613     }
71614   }
71615
71616   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
71617   return jresult;
71618 }
71619
71620
71621 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_RESOURCE_URL_get() {
71622   int jresult ;
71623   int result;
71624
71625   result = (int)Dali::Toolkit::ImageView::Property::RESOURCE_URL;
71626   jresult = (int)result;
71627   return jresult;
71628 }
71629
71630
71631 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_IMAGE_get() {
71632   int jresult ;
71633   int result;
71634
71635   result = (int)Dali::Toolkit::ImageView::Property::IMAGE;
71636   jresult = (int)result;
71637   return jresult;
71638 }
71639
71640
71641 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PRE_MULTIPLIED_ALPHA_get() {
71642   int jresult ;
71643   int result;
71644
71645   result = (int)Dali::Toolkit::ImageView::Property::PRE_MULTIPLIED_ALPHA;
71646   jresult = (int)result;
71647   return jresult;
71648 }
71649
71650
71651 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PIXEL_AREA_get() {
71652   int jresult ;
71653   int result;
71654
71655   result = (int)Dali::Toolkit::ImageView::Property::PIXEL_AREA;
71656   jresult = (int)result;
71657   return jresult;
71658 }
71659
71660
71661 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView_Property() {
71662   void * jresult ;
71663   Dali::Toolkit::ImageView::Property *result = 0 ;
71664
71665   {
71666     try {
71667       result = (Dali::Toolkit::ImageView::Property *)new Dali::Toolkit::ImageView::Property();
71668     } catch (std::out_of_range& e) {
71669       {
71670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71671       };
71672     } catch (std::exception& e) {
71673       {
71674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71675       };
71676     } catch (Dali::DaliException e) {
71677       {
71678         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71679       };
71680     } catch (...) {
71681       {
71682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71683       };
71684     }
71685   }
71686
71687   jresult = (void *)result;
71688   return jresult;
71689 }
71690
71691
71692 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView_Property(void * jarg1) {
71693   Dali::Toolkit::ImageView::Property *arg1 = (Dali::Toolkit::ImageView::Property *) 0 ;
71694
71695   arg1 = (Dali::Toolkit::ImageView::Property *)jarg1;
71696   {
71697     try {
71698       delete arg1;
71699     } catch (std::out_of_range& e) {
71700       {
71701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71702       };
71703     } catch (std::exception& e) {
71704       {
71705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71706       };
71707     } catch (Dali::DaliException e) {
71708       {
71709         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71710       };
71711     } catch (...) {
71712       {
71713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71714       };
71715     }
71716   }
71717
71718 }
71719
71720
71721 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_0() {
71722   void * jresult ;
71723   Dali::Toolkit::ImageView *result = 0 ;
71724
71725   {
71726     try {
71727       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView();
71728     } catch (std::out_of_range& e) {
71729       {
71730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71731       };
71732     } catch (std::exception& e) {
71733       {
71734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71735       };
71736     } catch (Dali::DaliException e) {
71737       {
71738         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71739       };
71740     } catch (...) {
71741       {
71742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71743       };
71744     }
71745   }
71746
71747   jresult = (void *)result;
71748   return jresult;
71749 }
71750
71751
71752 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_0() {
71753   void * jresult ;
71754   Dali::Toolkit::ImageView result;
71755
71756   {
71757     try {
71758       result = Dali::Toolkit::ImageView::New();
71759     } catch (std::out_of_range& e) {
71760       {
71761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71762       };
71763     } catch (std::exception& e) {
71764       {
71765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71766       };
71767     } catch (Dali::DaliException e) {
71768       {
71769         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71770       };
71771     } catch (...) {
71772       {
71773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71774       };
71775     }
71776   }
71777
71778   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
71779   return jresult;
71780 }
71781
71782
71783 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_1(void * jarg1) {
71784   void * jresult ;
71785   Dali::Image arg1 ;
71786   Dali::Image *argp1 ;
71787   Dali::Toolkit::ImageView result;
71788
71789   argp1 = (Dali::Image *)jarg1;
71790   if (!argp1) {
71791     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
71792     return 0;
71793   }
71794   arg1 = *argp1;
71795   {
71796     try {
71797       result = Dali::Toolkit::ImageView::New(arg1);
71798     } catch (std::out_of_range& e) {
71799       {
71800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71801       };
71802     } catch (std::exception& e) {
71803       {
71804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71805       };
71806     } catch (Dali::DaliException e) {
71807       {
71808         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71809       };
71810     } catch (...) {
71811       {
71812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71813       };
71814     }
71815   }
71816
71817   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
71818   return jresult;
71819 }
71820
71821
71822 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_2(char * jarg1) {
71823   void * jresult ;
71824   std::string *arg1 = 0 ;
71825   Dali::Toolkit::ImageView result;
71826
71827   if (!jarg1) {
71828     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
71829     return 0;
71830   }
71831   std::string arg1_str(jarg1);
71832   arg1 = &arg1_str;
71833   {
71834     try {
71835       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1);
71836     } catch (std::out_of_range& e) {
71837       {
71838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71839       };
71840     } catch (std::exception& e) {
71841       {
71842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71843       };
71844     } catch (Dali::DaliException e) {
71845       {
71846         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71847       };
71848     } catch (...) {
71849       {
71850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71851       };
71852     }
71853   }
71854
71855   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
71856
71857   //argout typemap for const std::string&
71858
71859   return jresult;
71860 }
71861
71862
71863 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_3(char * jarg1, void * jarg2) {
71864   void * jresult ;
71865   std::string *arg1 = 0 ;
71866   Dali::ImageDimensions arg2 ;
71867   Dali::ImageDimensions *argp2 ;
71868   Dali::Toolkit::ImageView result;
71869
71870   if (!jarg1) {
71871     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
71872     return 0;
71873   }
71874   std::string arg1_str(jarg1);
71875   arg1 = &arg1_str;
71876   argp2 = (Dali::ImageDimensions *)jarg2;
71877   if (!argp2) {
71878     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
71879     return 0;
71880   }
71881   arg2 = *argp2;
71882   {
71883     try {
71884       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1,arg2);
71885     } catch (std::out_of_range& e) {
71886       {
71887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71888       };
71889     } catch (std::exception& e) {
71890       {
71891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71892       };
71893     } catch (Dali::DaliException e) {
71894       {
71895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71896       };
71897     } catch (...) {
71898       {
71899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71900       };
71901     }
71902   }
71903
71904   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
71905
71906   //argout typemap for const std::string&
71907
71908   return jresult;
71909 }
71910
71911
71912 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView(void * jarg1) {
71913   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
71914
71915   arg1 = (Dali::Toolkit::ImageView *)jarg1;
71916   {
71917     try {
71918       delete arg1;
71919     } catch (std::out_of_range& e) {
71920       {
71921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71922       };
71923     } catch (std::exception& e) {
71924       {
71925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71926       };
71927     } catch (Dali::DaliException e) {
71928       {
71929         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71930       };
71931     } catch (...) {
71932       {
71933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71934       };
71935     }
71936   }
71937
71938 }
71939
71940
71941 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_1(void * jarg1) {
71942   void * jresult ;
71943   Dali::Toolkit::ImageView *arg1 = 0 ;
71944   Dali::Toolkit::ImageView *result = 0 ;
71945
71946   arg1 = (Dali::Toolkit::ImageView *)jarg1;
71947   if (!arg1) {
71948     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
71949     return 0;
71950   }
71951   {
71952     try {
71953       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView((Dali::Toolkit::ImageView const &)*arg1);
71954     } catch (std::out_of_range& e) {
71955       {
71956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71957       };
71958     } catch (std::exception& e) {
71959       {
71960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71961       };
71962     } catch (Dali::DaliException e) {
71963       {
71964         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71965       };
71966     } catch (...) {
71967       {
71968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71969       };
71970     }
71971   }
71972
71973   jresult = (void *)result;
71974   return jresult;
71975 }
71976
71977
71978 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_Assign(void * jarg1, void * jarg2) {
71979   void * jresult ;
71980   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
71981   Dali::Toolkit::ImageView *arg2 = 0 ;
71982   Dali::Toolkit::ImageView *result = 0 ;
71983
71984   arg1 = (Dali::Toolkit::ImageView *)jarg1;
71985   arg2 = (Dali::Toolkit::ImageView *)jarg2;
71986   if (!arg2) {
71987     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
71988     return 0;
71989   }
71990   {
71991     try {
71992       result = (Dali::Toolkit::ImageView *) &(arg1)->operator =((Dali::Toolkit::ImageView const &)*arg2);
71993     } catch (std::out_of_range& e) {
71994       {
71995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71996       };
71997     } catch (std::exception& e) {
71998       {
71999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72000       };
72001     } catch (Dali::DaliException e) {
72002       {
72003         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72004       };
72005     } catch (...) {
72006       {
72007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72008       };
72009     }
72010   }
72011
72012   jresult = (void *)result;
72013   return jresult;
72014 }
72015
72016
72017 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_DownCast(void * jarg1) {
72018   void * jresult ;
72019   Dali::BaseHandle arg1 ;
72020   Dali::BaseHandle *argp1 ;
72021   Dali::Toolkit::ImageView result;
72022
72023   argp1 = (Dali::BaseHandle *)jarg1;
72024   if (!argp1) {
72025     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
72026     return 0;
72027   }
72028   arg1 = *argp1;
72029   {
72030     try {
72031       result = Dali::Toolkit::ImageView::DownCast(arg1);
72032     } catch (std::out_of_range& e) {
72033       {
72034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72035       };
72036     } catch (std::exception& e) {
72037       {
72038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72039       };
72040     } catch (Dali::DaliException e) {
72041       {
72042         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72043       };
72044     } catch (...) {
72045       {
72046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72047       };
72048     }
72049   }
72050
72051   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
72052   return jresult;
72053 }
72054
72055
72056 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_0(void * jarg1, void * jarg2) {
72057   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
72058   Dali::Image arg2 ;
72059   Dali::Image *argp2 ;
72060
72061   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72062   argp2 = (Dali::Image *)jarg2;
72063   if (!argp2) {
72064     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
72065     return ;
72066   }
72067   arg2 = *argp2;
72068   {
72069     try {
72070       (arg1)->SetImage(arg2);
72071     } catch (std::out_of_range& e) {
72072       {
72073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72074       };
72075     } catch (std::exception& e) {
72076       {
72077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72078       };
72079     } catch (Dali::DaliException e) {
72080       {
72081         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72082       };
72083     } catch (...) {
72084       {
72085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72086       };
72087     }
72088   }
72089
72090 }
72091
72092
72093 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_1(void * jarg1, char * jarg2) {
72094   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
72095   std::string *arg2 = 0 ;
72096
72097   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72098   if (!jarg2) {
72099     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72100     return ;
72101   }
72102   std::string arg2_str(jarg2);
72103   arg2 = &arg2_str;
72104   {
72105     try {
72106       (arg1)->SetImage((std::string const &)*arg2);
72107     } catch (std::out_of_range& e) {
72108       {
72109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72110       };
72111     } catch (std::exception& e) {
72112       {
72113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72114       };
72115     } catch (Dali::DaliException e) {
72116       {
72117         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72118       };
72119     } catch (...) {
72120       {
72121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72122       };
72123     }
72124   }
72125
72126
72127   //argout typemap for const std::string&
72128
72129 }
72130
72131
72132 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
72133   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
72134   std::string *arg2 = 0 ;
72135   Dali::ImageDimensions arg3 ;
72136   Dali::ImageDimensions *argp3 ;
72137
72138   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72139   if (!jarg2) {
72140     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72141     return ;
72142   }
72143   std::string arg2_str(jarg2);
72144   arg2 = &arg2_str;
72145   argp3 = (Dali::ImageDimensions *)jarg3;
72146   if (!argp3) {
72147     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
72148     return ;
72149   }
72150   arg3 = *argp3;
72151   {
72152     try {
72153       (arg1)->SetImage((std::string const &)*arg2,arg3);
72154     } catch (std::out_of_range& e) {
72155       {
72156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72157       };
72158     } catch (std::exception& e) {
72159       {
72160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72161       };
72162     } catch (Dali::DaliException e) {
72163       {
72164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72165       };
72166     } catch (...) {
72167       {
72168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72169       };
72170     }
72171   }
72172
72173
72174   //argout typemap for const std::string&
72175
72176 }
72177
72178 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_GetImage(void * jarg1) {
72179   void * jresult ;
72180   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
72181   Dali::Image result;
72182
72183   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72184   {
72185     try {
72186       result = ((Dali::Toolkit::ImageView const *)arg1)->GetImage();
72187     } catch (std::out_of_range& e) {
72188       {
72189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72190       };
72191     } catch (std::exception& e) {
72192       {
72193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72194       };
72195     } catch (Dali::DaliException e) {
72196       {
72197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72198       };
72199     } catch (...) {
72200       {
72201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72202       };
72203     }
72204   }
72205
72206   jresult = new Dali::Image((const Dali::Image &)result);
72207   return jresult;
72208 }
72209
72210
72211 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_GEOMETRY_URL_get() {
72212   int jresult ;
72213   int result;
72214
72215   result = (int)Dali::Toolkit::Model3dView::Property::GEOMETRY_URL;
72216   jresult = (int)result;
72217   return jresult;
72218 }
72219
72220
72221 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_MATERIAL_URL_get() {
72222   int jresult ;
72223   int result;
72224
72225   result = (int)Dali::Toolkit::Model3dView::Property::MATERIAL_URL;
72226   jresult = (int)result;
72227   return jresult;
72228 }
72229
72230
72231 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_IMAGES_URL_get() {
72232   int jresult ;
72233   int result;
72234
72235   result = (int)Dali::Toolkit::Model3dView::Property::IMAGES_URL;
72236   jresult = (int)result;
72237   return jresult;
72238 }
72239
72240
72241 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_ILLUMINATION_TYPE_get() {
72242   int jresult ;
72243   int result;
72244
72245   result = (int)Dali::Toolkit::Model3dView::Property::ILLUMINATION_TYPE;
72246   jresult = (int)result;
72247   return jresult;
72248 }
72249
72250
72251 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE0_URL_get() {
72252   int jresult ;
72253   int result;
72254
72255   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE0_URL;
72256   jresult = (int)result;
72257   return jresult;
72258 }
72259
72260
72261 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE1_URL_get() {
72262   int jresult ;
72263   int result;
72264
72265   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE1_URL;
72266   jresult = (int)result;
72267   return jresult;
72268 }
72269
72270
72271 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE2_URL_get() {
72272   int jresult ;
72273   int result;
72274
72275   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE2_URL;
72276   jresult = (int)result;
72277   return jresult;
72278 }
72279
72280
72281 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_LIGHT_POSITION_get() {
72282   int jresult ;
72283   int result;
72284
72285   result = (int)Dali::Toolkit::Model3dView::Property::LIGHT_POSITION;
72286   jresult = (int)result;
72287   return jresult;
72288 }
72289
72290
72291 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView_Property() {
72292   void * jresult ;
72293   Dali::Toolkit::Model3dView::Property *result = 0 ;
72294
72295   {
72296     try {
72297       result = (Dali::Toolkit::Model3dView::Property *)new Dali::Toolkit::Model3dView::Property();
72298     } catch (std::out_of_range& e) {
72299       {
72300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72301       };
72302     } catch (std::exception& e) {
72303       {
72304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72305       };
72306     } catch (Dali::DaliException e) {
72307       {
72308         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72309       };
72310     } catch (...) {
72311       {
72312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72313       };
72314     }
72315   }
72316
72317   jresult = (void *)result;
72318   return jresult;
72319 }
72320
72321
72322 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView_Property(void * jarg1) {
72323   Dali::Toolkit::Model3dView::Property *arg1 = (Dali::Toolkit::Model3dView::Property *) 0 ;
72324
72325   arg1 = (Dali::Toolkit::Model3dView::Property *)jarg1;
72326   {
72327     try {
72328       delete arg1;
72329     } catch (std::out_of_range& e) {
72330       {
72331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72332       };
72333     } catch (std::exception& e) {
72334       {
72335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72336       };
72337     } catch (Dali::DaliException e) {
72338       {
72339         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72340       };
72341     } catch (...) {
72342       {
72343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72344       };
72345     }
72346   }
72347
72348 }
72349
72350
72351 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_0() {
72352   void * jresult ;
72353   Dali::Toolkit::Model3dView result;
72354
72355   {
72356     try {
72357       result = Dali::Toolkit::Model3dView::New();
72358     } catch (std::out_of_range& e) {
72359       {
72360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72361       };
72362     } catch (std::exception& e) {
72363       {
72364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72365       };
72366     } catch (Dali::DaliException e) {
72367       {
72368         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72369       };
72370     } catch (...) {
72371       {
72372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72373       };
72374     }
72375   }
72376
72377   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
72378   return jresult;
72379 }
72380
72381
72382 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_1(char * jarg1, char * jarg2, char * jarg3) {
72383   void * jresult ;
72384   std::string *arg1 = 0 ;
72385   std::string *arg2 = 0 ;
72386   std::string *arg3 = 0 ;
72387   Dali::Toolkit::Model3dView result;
72388
72389   if (!jarg1) {
72390     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72391     return 0;
72392   }
72393   std::string arg1_str(jarg1);
72394   arg1 = &arg1_str;
72395   if (!jarg2) {
72396     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72397     return 0;
72398   }
72399   std::string arg2_str(jarg2);
72400   arg2 = &arg2_str;
72401   if (!jarg3) {
72402     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72403     return 0;
72404   }
72405   std::string arg3_str(jarg3);
72406   arg3 = &arg3_str;
72407   {
72408     try {
72409       result = Dali::Toolkit::Model3dView::New((std::string const &)*arg1,(std::string const &)*arg2,(std::string const &)*arg3);
72410     } catch (std::out_of_range& e) {
72411       {
72412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72413       };
72414     } catch (std::exception& e) {
72415       {
72416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72417       };
72418     } catch (Dali::DaliException e) {
72419       {
72420         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72421       };
72422     } catch (...) {
72423       {
72424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72425       };
72426     }
72427   }
72428
72429   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
72430
72431   //argout typemap for const std::string&
72432
72433
72434   //argout typemap for const std::string&
72435
72436
72437   //argout typemap for const std::string&
72438
72439   return jresult;
72440 }
72441
72442
72443 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_0() {
72444   void * jresult ;
72445   Dali::Toolkit::Model3dView *result = 0 ;
72446
72447   {
72448     try {
72449       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView();
72450     } catch (std::out_of_range& e) {
72451       {
72452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72453       };
72454     } catch (std::exception& e) {
72455       {
72456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72457       };
72458     } catch (Dali::DaliException e) {
72459       {
72460         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72461       };
72462     } catch (...) {
72463       {
72464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72465       };
72466     }
72467   }
72468
72469   jresult = (void *)result;
72470   return jresult;
72471 }
72472
72473
72474 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView(void * jarg1) {
72475   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
72476
72477   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
72478   {
72479     try {
72480       delete arg1;
72481     } catch (std::out_of_range& e) {
72482       {
72483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72484       };
72485     } catch (std::exception& e) {
72486       {
72487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72488       };
72489     } catch (Dali::DaliException e) {
72490       {
72491         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72492       };
72493     } catch (...) {
72494       {
72495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72496       };
72497     }
72498   }
72499
72500 }
72501
72502
72503 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_1(void * jarg1) {
72504   void * jresult ;
72505   Dali::Toolkit::Model3dView *arg1 = 0 ;
72506   Dali::Toolkit::Model3dView *result = 0 ;
72507
72508   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
72509   if (!arg1) {
72510     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
72511     return 0;
72512   }
72513   {
72514     try {
72515       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView((Dali::Toolkit::Model3dView const &)*arg1);
72516     } catch (std::out_of_range& e) {
72517       {
72518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72519       };
72520     } catch (std::exception& e) {
72521       {
72522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72523       };
72524     } catch (Dali::DaliException e) {
72525       {
72526         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72527       };
72528     } catch (...) {
72529       {
72530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72531       };
72532     }
72533   }
72534
72535   jresult = (void *)result;
72536   return jresult;
72537 }
72538
72539
72540 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_Assign(void * jarg1, void * jarg2) {
72541   void * jresult ;
72542   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
72543   Dali::Toolkit::Model3dView *arg2 = 0 ;
72544   Dali::Toolkit::Model3dView *result = 0 ;
72545
72546   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
72547   arg2 = (Dali::Toolkit::Model3dView *)jarg2;
72548   if (!arg2) {
72549     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
72550     return 0;
72551   }
72552   {
72553     try {
72554       result = (Dali::Toolkit::Model3dView *) &(arg1)->operator =((Dali::Toolkit::Model3dView const &)*arg2);
72555     } catch (std::out_of_range& e) {
72556       {
72557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72558       };
72559     } catch (std::exception& e) {
72560       {
72561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72562       };
72563     } catch (Dali::DaliException e) {
72564       {
72565         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72566       };
72567     } catch (...) {
72568       {
72569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72570       };
72571     }
72572   }
72573
72574   jresult = (void *)result;
72575   return jresult;
72576 }
72577
72578
72579 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_DownCast(void * jarg1) {
72580   void * jresult ;
72581   Dali::BaseHandle arg1 ;
72582   Dali::BaseHandle *argp1 ;
72583   Dali::Toolkit::Model3dView result;
72584
72585   argp1 = (Dali::BaseHandle *)jarg1;
72586   if (!argp1) {
72587     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
72588     return 0;
72589   }
72590   arg1 = *argp1;
72591   {
72592     try {
72593       result = Dali::Toolkit::Model3dView::DownCast(arg1);
72594     } catch (std::out_of_range& e) {
72595       {
72596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72597       };
72598     } catch (std::exception& e) {
72599       {
72600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72601       };
72602     } catch (Dali::DaliException e) {
72603       {
72604         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72605       };
72606     } catch (...) {
72607       {
72608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72609       };
72610     }
72611   }
72612
72613   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
72614   return jresult;
72615 }
72616
72617
72618 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_DIRECTION_get() {
72619   int jresult ;
72620   int result;
72621
72622   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_DIRECTION;
72623   jresult = (int)result;
72624   return jresult;
72625 }
72626
72627
72628 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HEIGHT_POLICY_get() {
72629   int jresult ;
72630   int result;
72631
72632   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HEIGHT_POLICY;
72633   jresult = (int)result;
72634   return jresult;
72635 }
72636
72637
72638 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_FIXED_HEIGHT_get() {
72639   int jresult ;
72640   int result;
72641
72642   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_FIXED_HEIGHT;
72643   jresult = (int)result;
72644   return jresult;
72645 }
72646
72647
72648 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_SHOW_DURATION_get() {
72649   int jresult ;
72650   int result;
72651
72652   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_SHOW_DURATION;
72653   jresult = (int)result;
72654   return jresult;
72655 }
72656
72657
72658 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HIDE_DURATION_get() {
72659   int jresult ;
72660   int result;
72661
72662   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HIDE_DURATION;
72663   jresult = (int)result;
72664   return jresult;
72665 }
72666
72667
72668 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_POSITION_INTERVALS_get() {
72669   int jresult ;
72670   int result;
72671
72672   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_POSITION_INTERVALS;
72673   jresult = (int)result;
72674   return jresult;
72675 }
72676
72677
72678 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_MINIMUM_HEIGHT_get() {
72679   int jresult ;
72680   int result;
72681
72682   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_MINIMUM_HEIGHT;
72683   jresult = (int)result;
72684   return jresult;
72685 }
72686
72687
72688 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_START_PADDING_get() {
72689   int jresult ;
72690   int result;
72691
72692   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_START_PADDING;
72693   jresult = (int)result;
72694   return jresult;
72695 }
72696
72697
72698 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_END_PADDING_get() {
72699   int jresult ;
72700   int result;
72701
72702   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_END_PADDING;
72703   jresult = (int)result;
72704   return jresult;
72705 }
72706
72707
72708 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar_Property() {
72709   void * jresult ;
72710   Dali::Toolkit::ScrollBar::Property *result = 0 ;
72711
72712   {
72713     try {
72714       result = (Dali::Toolkit::ScrollBar::Property *)new Dali::Toolkit::ScrollBar::Property();
72715     } catch (std::out_of_range& e) {
72716       {
72717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72718       };
72719     } catch (std::exception& e) {
72720       {
72721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72722       };
72723     } catch (Dali::DaliException e) {
72724       {
72725         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72726       };
72727     } catch (...) {
72728       {
72729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72730       };
72731     }
72732   }
72733
72734   jresult = (void *)result;
72735   return jresult;
72736 }
72737
72738
72739 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar_Property(void * jarg1) {
72740   Dali::Toolkit::ScrollBar::Property *arg1 = (Dali::Toolkit::ScrollBar::Property *) 0 ;
72741
72742   arg1 = (Dali::Toolkit::ScrollBar::Property *)jarg1;
72743   {
72744     try {
72745       delete arg1;
72746     } catch (std::out_of_range& e) {
72747       {
72748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72749       };
72750     } catch (std::exception& e) {
72751       {
72752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72753       };
72754     } catch (Dali::DaliException e) {
72755       {
72756         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72757       };
72758     } catch (...) {
72759       {
72760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72761       };
72762     }
72763   }
72764
72765 }
72766
72767
72768 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_0() {
72769   void * jresult ;
72770   Dali::Toolkit::ScrollBar *result = 0 ;
72771
72772   {
72773     try {
72774       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar();
72775     } catch (std::out_of_range& e) {
72776       {
72777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72778       };
72779     } catch (std::exception& e) {
72780       {
72781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72782       };
72783     } catch (Dali::DaliException e) {
72784       {
72785         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72786       };
72787     } catch (...) {
72788       {
72789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72790       };
72791     }
72792   }
72793
72794   jresult = (void *)result;
72795   return jresult;
72796 }
72797
72798
72799 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_1(void * jarg1) {
72800   void * jresult ;
72801   Dali::Toolkit::ScrollBar *arg1 = 0 ;
72802   Dali::Toolkit::ScrollBar *result = 0 ;
72803
72804   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72805   if (!arg1) {
72806     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
72807     return 0;
72808   }
72809   {
72810     try {
72811       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar((Dali::Toolkit::ScrollBar const &)*arg1);
72812     } catch (std::out_of_range& e) {
72813       {
72814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72815       };
72816     } catch (std::exception& e) {
72817       {
72818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72819       };
72820     } catch (Dali::DaliException e) {
72821       {
72822         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72823       };
72824     } catch (...) {
72825       {
72826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72827       };
72828     }
72829   }
72830
72831   jresult = (void *)result;
72832   return jresult;
72833 }
72834
72835
72836 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_Assign(void * jarg1, void * jarg2) {
72837   void * jresult ;
72838   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72839   Dali::Toolkit::ScrollBar *arg2 = 0 ;
72840   Dali::Toolkit::ScrollBar *result = 0 ;
72841
72842   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72843   arg2 = (Dali::Toolkit::ScrollBar *)jarg2;
72844   if (!arg2) {
72845     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
72846     return 0;
72847   }
72848   {
72849     try {
72850       result = (Dali::Toolkit::ScrollBar *) &(arg1)->operator =((Dali::Toolkit::ScrollBar const &)*arg2);
72851     } catch (std::out_of_range& e) {
72852       {
72853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72854       };
72855     } catch (std::exception& e) {
72856       {
72857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72858       };
72859     } catch (Dali::DaliException e) {
72860       {
72861         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72862       };
72863     } catch (...) {
72864       {
72865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72866       };
72867     }
72868   }
72869
72870   jresult = (void *)result;
72871   return jresult;
72872 }
72873
72874
72875 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar(void * jarg1) {
72876   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72877
72878   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72879   {
72880     try {
72881       delete arg1;
72882     } catch (std::out_of_range& e) {
72883       {
72884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72885       };
72886     } catch (std::exception& e) {
72887       {
72888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72889       };
72890     } catch (Dali::DaliException e) {
72891       {
72892         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72893       };
72894     } catch (...) {
72895       {
72896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72897       };
72898     }
72899   }
72900
72901 }
72902
72903
72904 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_0(int jarg1) {
72905   void * jresult ;
72906   Dali::Toolkit::ScrollBar::Direction arg1 ;
72907   Dali::Toolkit::ScrollBar result;
72908
72909   arg1 = (Dali::Toolkit::ScrollBar::Direction)jarg1;
72910   {
72911     try {
72912       result = Dali::Toolkit::ScrollBar::New(arg1);
72913     } catch (std::out_of_range& e) {
72914       {
72915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72916       };
72917     } catch (std::exception& e) {
72918       {
72919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72920       };
72921     } catch (Dali::DaliException e) {
72922       {
72923         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72924       };
72925     } catch (...) {
72926       {
72927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72928       };
72929     }
72930   }
72931
72932   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
72933   return jresult;
72934 }
72935
72936
72937 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_1() {
72938   void * jresult ;
72939   Dali::Toolkit::ScrollBar result;
72940
72941   {
72942     try {
72943       result = Dali::Toolkit::ScrollBar::New();
72944     } catch (std::out_of_range& e) {
72945       {
72946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72947       };
72948     } catch (std::exception& e) {
72949       {
72950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72951       };
72952     } catch (Dali::DaliException e) {
72953       {
72954         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72955       };
72956     } catch (...) {
72957       {
72958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72959       };
72960     }
72961   }
72962
72963   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
72964   return jresult;
72965 }
72966
72967
72968 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_DownCast(void * jarg1) {
72969   void * jresult ;
72970   Dali::BaseHandle arg1 ;
72971   Dali::BaseHandle *argp1 ;
72972   Dali::Toolkit::ScrollBar result;
72973
72974   argp1 = (Dali::BaseHandle *)jarg1;
72975   if (!argp1) {
72976     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
72977     return 0;
72978   }
72979   arg1 = *argp1;
72980   {
72981     try {
72982       result = Dali::Toolkit::ScrollBar::DownCast(arg1);
72983     } catch (std::out_of_range& e) {
72984       {
72985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72986       };
72987     } catch (std::exception& e) {
72988       {
72989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72990       };
72991     } catch (Dali::DaliException e) {
72992       {
72993         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72994       };
72995     } catch (...) {
72996       {
72997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72998       };
72999     }
73000   }
73001
73002   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
73003   return jresult;
73004 }
73005
73006
73007 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPropertySource(void * jarg1, void * jarg2, int jarg3, int jarg4, int jarg5, int jarg6) {
73008   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73009   Dali::Handle arg2 ;
73010   Dali::Property::Index arg3 ;
73011   Dali::Property::Index arg4 ;
73012   Dali::Property::Index arg5 ;
73013   Dali::Property::Index arg6 ;
73014   Dali::Handle *argp2 ;
73015
73016   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73017   argp2 = (Dali::Handle *)jarg2;
73018   if (!argp2) {
73019     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Handle", 0);
73020     return ;
73021   }
73022   arg2 = *argp2;
73023   arg3 = (Dali::Property::Index)jarg3;
73024   arg4 = (Dali::Property::Index)jarg4;
73025   arg5 = (Dali::Property::Index)jarg5;
73026   arg6 = (Dali::Property::Index)jarg6;
73027   {
73028     try {
73029       (arg1)->SetScrollPropertySource(arg2,arg3,arg4,arg5,arg6);
73030     } catch (std::out_of_range& e) {
73031       {
73032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73033       };
73034     } catch (std::exception& e) {
73035       {
73036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73037       };
73038     } catch (Dali::DaliException e) {
73039       {
73040         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73041       };
73042     } catch (...) {
73043       {
73044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73045       };
73046     }
73047   }
73048
73049 }
73050
73051
73052 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollIndicator(void * jarg1, void * jarg2) {
73053   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73054   Dali::Actor arg2 ;
73055   Dali::Actor *argp2 ;
73056
73057   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73058   argp2 = (Dali::Actor *)jarg2;
73059   if (!argp2) {
73060     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
73061     return ;
73062   }
73063   arg2 = *argp2;
73064   {
73065     try {
73066       (arg1)->SetScrollIndicator(arg2);
73067     } catch (std::out_of_range& e) {
73068       {
73069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73070       };
73071     } catch (std::exception& e) {
73072       {
73073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73074       };
73075     } catch (Dali::DaliException e) {
73076       {
73077         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73078       };
73079     } catch (...) {
73080       {
73081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73082       };
73083     }
73084   }
73085
73086 }
73087
73088
73089 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollIndicator(void * jarg1) {
73090   void * jresult ;
73091   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73092   Dali::Actor result;
73093
73094   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73095   {
73096     try {
73097       result = (arg1)->GetScrollIndicator();
73098     } catch (std::out_of_range& e) {
73099       {
73100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73101       };
73102     } catch (std::exception& e) {
73103       {
73104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73105       };
73106     } catch (Dali::DaliException e) {
73107       {
73108         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73109       };
73110     } catch (...) {
73111       {
73112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73113       };
73114     }
73115   }
73116
73117   jresult = new Dali::Actor((const Dali::Actor &)result);
73118   return jresult;
73119 }
73120
73121
73122 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPositionIntervals(void * jarg1, void * jarg2) {
73123   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73124   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg2 = 0 ;
73125
73126   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73127   arg2 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg2;
73128   if (!arg2) {
73129     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
73130     return ;
73131   }
73132   {
73133     try {
73134       (arg1)->SetScrollPositionIntervals((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg2);
73135     } catch (std::out_of_range& e) {
73136       {
73137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73138       };
73139     } catch (std::exception& e) {
73140       {
73141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73142       };
73143     } catch (Dali::DaliException e) {
73144       {
73145         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73146       };
73147     } catch (...) {
73148       {
73149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73150       };
73151     }
73152   }
73153
73154 }
73155
73156
73157 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollPositionIntervals(void * jarg1) {
73158   void * jresult ;
73159   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73160
73161   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73162   {
73163     try {
73164       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()));
73165     } catch (std::out_of_range& e) {
73166       {
73167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73168       };
73169     } catch (std::exception& e) {
73170       {
73171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73172       };
73173     } catch (...) {
73174       {
73175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73176       };
73177     }
73178   }
73179   return jresult;
73180 }
73181
73182
73183 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollDirection(void * jarg1, int jarg2) {
73184   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73185   Dali::Toolkit::ScrollBar::Direction arg2 ;
73186
73187   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73188   arg2 = (Dali::Toolkit::ScrollBar::Direction)jarg2;
73189   {
73190     try {
73191       (arg1)->SetScrollDirection(arg2);
73192     } catch (std::out_of_range& e) {
73193       {
73194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73195       };
73196     } catch (std::exception& e) {
73197       {
73198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73199       };
73200     } catch (Dali::DaliException e) {
73201       {
73202         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73203       };
73204     } catch (...) {
73205       {
73206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73207       };
73208     }
73209   }
73210
73211 }
73212
73213
73214 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollDirection(void * jarg1) {
73215   int jresult ;
73216   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73217   Dali::Toolkit::ScrollBar::Direction result;
73218
73219   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73220   {
73221     try {
73222       result = (Dali::Toolkit::ScrollBar::Direction)((Dali::Toolkit::ScrollBar const *)arg1)->GetScrollDirection();
73223     } catch (std::out_of_range& e) {
73224       {
73225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73226       };
73227     } catch (std::exception& e) {
73228       {
73229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73230       };
73231     } catch (Dali::DaliException e) {
73232       {
73233         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73234       };
73235     } catch (...) {
73236       {
73237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73238       };
73239     }
73240   }
73241
73242   jresult = (int)result;
73243   return jresult;
73244 }
73245
73246
73247 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHeightPolicy(void * jarg1, int jarg2) {
73248   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73249   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy arg2 ;
73250
73251   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73252   arg2 = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)jarg2;
73253   {
73254     try {
73255       (arg1)->SetIndicatorHeightPolicy(arg2);
73256     } catch (std::out_of_range& e) {
73257       {
73258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73259       };
73260     } catch (std::exception& e) {
73261       {
73262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73263       };
73264     } catch (Dali::DaliException e) {
73265       {
73266         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73267       };
73268     } catch (...) {
73269       {
73270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73271       };
73272     }
73273   }
73274
73275 }
73276
73277
73278 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHeightPolicy(void * jarg1) {
73279   int jresult ;
73280   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73281   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy result;
73282
73283   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73284   {
73285     try {
73286       result = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHeightPolicy();
73287     } catch (std::out_of_range& e) {
73288       {
73289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73290       };
73291     } catch (std::exception& e) {
73292       {
73293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73294       };
73295     } catch (Dali::DaliException e) {
73296       {
73297         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73298       };
73299     } catch (...) {
73300       {
73301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73302       };
73303     }
73304   }
73305
73306   jresult = (int)result;
73307   return jresult;
73308 }
73309
73310
73311 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorFixedHeight(void * jarg1, float jarg2) {
73312   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73313   float arg2 ;
73314
73315   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73316   arg2 = (float)jarg2;
73317   {
73318     try {
73319       (arg1)->SetIndicatorFixedHeight(arg2);
73320     } catch (std::out_of_range& e) {
73321       {
73322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73323       };
73324     } catch (std::exception& e) {
73325       {
73326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73327       };
73328     } catch (Dali::DaliException e) {
73329       {
73330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73331       };
73332     } catch (...) {
73333       {
73334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73335       };
73336     }
73337   }
73338
73339 }
73340
73341
73342 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorFixedHeight(void * jarg1) {
73343   float jresult ;
73344   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73345   float result;
73346
73347   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73348   {
73349     try {
73350       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorFixedHeight();
73351     } catch (std::out_of_range& e) {
73352       {
73353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73354       };
73355     } catch (std::exception& e) {
73356       {
73357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73358       };
73359     } catch (Dali::DaliException e) {
73360       {
73361         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73362       };
73363     } catch (...) {
73364       {
73365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73366       };
73367     }
73368   }
73369
73370   jresult = result;
73371   return jresult;
73372 }
73373
73374
73375 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorShowDuration(void * jarg1, float jarg2) {
73376   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73377   float arg2 ;
73378
73379   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73380   arg2 = (float)jarg2;
73381   {
73382     try {
73383       (arg1)->SetIndicatorShowDuration(arg2);
73384     } catch (std::out_of_range& e) {
73385       {
73386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73387       };
73388     } catch (std::exception& e) {
73389       {
73390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73391       };
73392     } catch (Dali::DaliException e) {
73393       {
73394         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73395       };
73396     } catch (...) {
73397       {
73398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73399       };
73400     }
73401   }
73402
73403 }
73404
73405
73406 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorShowDuration(void * jarg1) {
73407   float jresult ;
73408   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73409   float result;
73410
73411   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73412   {
73413     try {
73414       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorShowDuration();
73415     } catch (std::out_of_range& e) {
73416       {
73417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73418       };
73419     } catch (std::exception& e) {
73420       {
73421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73422       };
73423     } catch (Dali::DaliException e) {
73424       {
73425         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73426       };
73427     } catch (...) {
73428       {
73429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73430       };
73431     }
73432   }
73433
73434   jresult = result;
73435   return jresult;
73436 }
73437
73438
73439 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHideDuration(void * jarg1, float jarg2) {
73440   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73441   float arg2 ;
73442
73443   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73444   arg2 = (float)jarg2;
73445   {
73446     try {
73447       (arg1)->SetIndicatorHideDuration(arg2);
73448     } catch (std::out_of_range& e) {
73449       {
73450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73451       };
73452     } catch (std::exception& e) {
73453       {
73454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73455       };
73456     } catch (Dali::DaliException e) {
73457       {
73458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73459       };
73460     } catch (...) {
73461       {
73462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73463       };
73464     }
73465   }
73466
73467 }
73468
73469
73470 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHideDuration(void * jarg1) {
73471   float jresult ;
73472   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73473   float result;
73474
73475   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73476   {
73477     try {
73478       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHideDuration();
73479     } catch (std::out_of_range& e) {
73480       {
73481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73482       };
73483     } catch (std::exception& e) {
73484       {
73485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73486       };
73487     } catch (Dali::DaliException e) {
73488       {
73489         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73490       };
73491     } catch (...) {
73492       {
73493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73494       };
73495     }
73496   }
73497
73498   jresult = result;
73499   return jresult;
73500 }
73501
73502
73503 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_ShowIndicator(void * jarg1) {
73504   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73505
73506   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73507   {
73508     try {
73509       (arg1)->ShowIndicator();
73510     } catch (std::out_of_range& e) {
73511       {
73512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73513       };
73514     } catch (std::exception& e) {
73515       {
73516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73517       };
73518     } catch (Dali::DaliException e) {
73519       {
73520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73521       };
73522     } catch (...) {
73523       {
73524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73525       };
73526     }
73527   }
73528
73529 }
73530
73531
73532 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_HideIndicator(void * jarg1) {
73533   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73534
73535   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73536   {
73537     try {
73538       (arg1)->HideIndicator();
73539     } catch (std::out_of_range& e) {
73540       {
73541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73542       };
73543     } catch (std::exception& e) {
73544       {
73545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73546       };
73547     } catch (Dali::DaliException e) {
73548       {
73549         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73550       };
73551     } catch (...) {
73552       {
73553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73554       };
73555     }
73556   }
73557
73558 }
73559
73560
73561 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_PanFinishedSignal(void * jarg1) {
73562   void * jresult ;
73563   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73564   Dali::Toolkit::ScrollBar::PanFinishedSignalType *result = 0 ;
73565
73566   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73567   {
73568     try {
73569       result = (Dali::Toolkit::ScrollBar::PanFinishedSignalType *) &(arg1)->PanFinishedSignal();
73570     } catch (std::out_of_range& e) {
73571       {
73572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73573       };
73574     } catch (std::exception& e) {
73575       {
73576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73577       };
73578     } catch (Dali::DaliException e) {
73579       {
73580         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73581       };
73582     } catch (...) {
73583       {
73584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73585       };
73586     }
73587   }
73588
73589   jresult = (void *)result;
73590   return jresult;
73591 }
73592
73593
73594 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_ScrollPositionIntervalReachedSignal(void * jarg1) {
73595   void * jresult ;
73596   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73597   Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *result = 0 ;
73598
73599   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73600   {
73601     try {
73602       result = (Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *) &(arg1)->ScrollPositionIntervalReachedSignal();
73603     } catch (std::out_of_range& e) {
73604       {
73605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73606       };
73607     } catch (std::exception& e) {
73608       {
73609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73610       };
73611     } catch (Dali::DaliException e) {
73612       {
73613         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73614       };
73615     } catch (...) {
73616       {
73617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73618       };
73619     }
73620   }
73621
73622   jresult = (void *)result;
73623   return jresult;
73624 }
73625
73626
73627 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_EFFECT_COLOR_get() {
73628   int jresult ;
73629   int result;
73630
73631   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_EFFECT_COLOR;
73632   jresult = (int)result;
73633   return jresult;
73634 }
73635
73636
73637 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ANIMATION_SPEED_get() {
73638   int jresult ;
73639   int result;
73640
73641   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ANIMATION_SPEED;
73642   jresult = (int)result;
73643   return jresult;
73644 }
73645
73646
73647 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ENABLED_get() {
73648   int jresult ;
73649   int result;
73650
73651   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ENABLED;
73652   jresult = (int)result;
73653   return jresult;
73654 }
73655
73656
73657 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_SIZE_get() {
73658   int jresult ;
73659   int result;
73660
73661   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_SIZE;
73662   jresult = (int)result;
73663   return jresult;
73664 }
73665
73666
73667 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_TO_ALPHA_FUNCTION_get() {
73668   int jresult ;
73669   int result;
73670
73671   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_TO_ALPHA_FUNCTION;
73672   jresult = (int)result;
73673   return jresult;
73674 }
73675
73676
73677 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_RELATIVE_POSITION_get() {
73678   int jresult ;
73679   int result;
73680
73681   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_RELATIVE_POSITION;
73682   jresult = (int)result;
73683   return jresult;
73684 }
73685
73686
73687 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_get() {
73688   int jresult ;
73689   int result;
73690
73691   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN;
73692   jresult = (int)result;
73693   return jresult;
73694 }
73695
73696
73697 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_X_get() {
73698   int jresult ;
73699   int result;
73700
73701   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_X;
73702   jresult = (int)result;
73703   return jresult;
73704 }
73705
73706
73707 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_Y_get() {
73708   int jresult ;
73709   int result;
73710
73711   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_Y;
73712   jresult = (int)result;
73713   return jresult;
73714 }
73715
73716
73717 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_get() {
73718   int jresult ;
73719   int result;
73720
73721   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX;
73722   jresult = (int)result;
73723   return jresult;
73724 }
73725
73726
73727 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_X_get() {
73728   int jresult ;
73729   int result;
73730
73731   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_X;
73732   jresult = (int)result;
73733   return jresult;
73734 }
73735
73736
73737 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_Y_get() {
73738   int jresult ;
73739   int result;
73740
73741   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_Y;
73742   jresult = (int)result;
73743   return jresult;
73744 }
73745
73746
73747 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_VERTICAL_get() {
73748   int jresult ;
73749   int result;
73750
73751   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_VERTICAL;
73752   jresult = (int)result;
73753   return jresult;
73754 }
73755
73756
73757 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_HORIZONTAL_get() {
73758   int jresult ;
73759   int result;
73760
73761   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_HORIZONTAL;
73762   jresult = (int)result;
73763   return jresult;
73764 }
73765
73766
73767 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable_Property() {
73768   void * jresult ;
73769   Dali::Toolkit::Scrollable::Property *result = 0 ;
73770
73771   {
73772     try {
73773       result = (Dali::Toolkit::Scrollable::Property *)new Dali::Toolkit::Scrollable::Property();
73774     } catch (std::out_of_range& e) {
73775       {
73776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73777       };
73778     } catch (std::exception& e) {
73779       {
73780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73781       };
73782     } catch (Dali::DaliException e) {
73783       {
73784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73785       };
73786     } catch (...) {
73787       {
73788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73789       };
73790     }
73791   }
73792
73793   jresult = (void *)result;
73794   return jresult;
73795 }
73796
73797
73798 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable_Property(void * jarg1) {
73799   Dali::Toolkit::Scrollable::Property *arg1 = (Dali::Toolkit::Scrollable::Property *) 0 ;
73800
73801   arg1 = (Dali::Toolkit::Scrollable::Property *)jarg1;
73802   {
73803     try {
73804       delete arg1;
73805     } catch (std::out_of_range& e) {
73806       {
73807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73808       };
73809     } catch (std::exception& e) {
73810       {
73811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73812       };
73813     } catch (Dali::DaliException e) {
73814       {
73815         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73816       };
73817     } catch (...) {
73818       {
73819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73820       };
73821     }
73822   }
73823
73824 }
73825
73826
73827 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_0() {
73828   void * jresult ;
73829   Dali::Toolkit::Scrollable *result = 0 ;
73830
73831   {
73832     try {
73833       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable();
73834     } catch (std::out_of_range& e) {
73835       {
73836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73837       };
73838     } catch (std::exception& e) {
73839       {
73840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73841       };
73842     } catch (Dali::DaliException e) {
73843       {
73844         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73845       };
73846     } catch (...) {
73847       {
73848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73849       };
73850     }
73851   }
73852
73853   jresult = (void *)result;
73854   return jresult;
73855 }
73856
73857
73858 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_1(void * jarg1) {
73859   void * jresult ;
73860   Dali::Toolkit::Scrollable *arg1 = 0 ;
73861   Dali::Toolkit::Scrollable *result = 0 ;
73862
73863   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
73864   if (!arg1) {
73865     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
73866     return 0;
73867   }
73868   {
73869     try {
73870       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable((Dali::Toolkit::Scrollable const &)*arg1);
73871     } catch (std::out_of_range& e) {
73872       {
73873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73874       };
73875     } catch (std::exception& e) {
73876       {
73877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73878       };
73879     } catch (Dali::DaliException e) {
73880       {
73881         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73882       };
73883     } catch (...) {
73884       {
73885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73886       };
73887     }
73888   }
73889
73890   jresult = (void *)result;
73891   return jresult;
73892 }
73893
73894
73895 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_Assign(void * jarg1, void * jarg2) {
73896   void * jresult ;
73897   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
73898   Dali::Toolkit::Scrollable *arg2 = 0 ;
73899   Dali::Toolkit::Scrollable *result = 0 ;
73900
73901   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
73902   arg2 = (Dali::Toolkit::Scrollable *)jarg2;
73903   if (!arg2) {
73904     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
73905     return 0;
73906   }
73907   {
73908     try {
73909       result = (Dali::Toolkit::Scrollable *) &(arg1)->operator =((Dali::Toolkit::Scrollable const &)*arg2);
73910     } catch (std::out_of_range& e) {
73911       {
73912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73913       };
73914     } catch (std::exception& e) {
73915       {
73916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73917       };
73918     } catch (Dali::DaliException e) {
73919       {
73920         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73921       };
73922     } catch (...) {
73923       {
73924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73925       };
73926     }
73927   }
73928
73929   jresult = (void *)result;
73930   return jresult;
73931 }
73932
73933
73934 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable(void * jarg1) {
73935   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
73936
73937   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
73938   {
73939     try {
73940       delete arg1;
73941     } catch (std::out_of_range& e) {
73942       {
73943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73944       };
73945     } catch (std::exception& e) {
73946       {
73947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73948       };
73949     } catch (Dali::DaliException e) {
73950       {
73951         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73952       };
73953     } catch (...) {
73954       {
73955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73956       };
73957     }
73958   }
73959
73960 }
73961
73962
73963 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_DownCast(void * jarg1) {
73964   void * jresult ;
73965   Dali::BaseHandle arg1 ;
73966   Dali::BaseHandle *argp1 ;
73967   Dali::Toolkit::Scrollable result;
73968
73969   argp1 = (Dali::BaseHandle *)jarg1;
73970   if (!argp1) {
73971     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
73972     return 0;
73973   }
73974   arg1 = *argp1;
73975   {
73976     try {
73977       result = Dali::Toolkit::Scrollable::DownCast(arg1);
73978     } catch (std::out_of_range& e) {
73979       {
73980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73981       };
73982     } catch (std::exception& e) {
73983       {
73984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73985       };
73986     } catch (Dali::DaliException e) {
73987       {
73988         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73989       };
73990     } catch (...) {
73991       {
73992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73993       };
73994     }
73995   }
73996
73997   jresult = new Dali::Toolkit::Scrollable((const Dali::Toolkit::Scrollable &)result);
73998   return jresult;
73999 }
74000
74001
74002 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Scrollable_IsOvershootEnabled(void * jarg1) {
74003   unsigned int jresult ;
74004   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74005   bool result;
74006
74007   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74008   {
74009     try {
74010       result = (bool)((Dali::Toolkit::Scrollable const *)arg1)->IsOvershootEnabled();
74011     } catch (std::out_of_range& e) {
74012       {
74013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74014       };
74015     } catch (std::exception& e) {
74016       {
74017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74018       };
74019     } catch (Dali::DaliException e) {
74020       {
74021         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74022       };
74023     } catch (...) {
74024       {
74025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74026       };
74027     }
74028   }
74029
74030   jresult = result;
74031   return jresult;
74032 }
74033
74034
74035 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEnabled(void * jarg1, unsigned int jarg2) {
74036   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74037   bool arg2 ;
74038
74039   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74040   arg2 = jarg2 ? true : false;
74041   {
74042     try {
74043       (arg1)->SetOvershootEnabled(arg2);
74044     } catch (std::out_of_range& e) {
74045       {
74046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74047       };
74048     } catch (std::exception& e) {
74049       {
74050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74051       };
74052     } catch (Dali::DaliException e) {
74053       {
74054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74055       };
74056     } catch (...) {
74057       {
74058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74059       };
74060     }
74061   }
74062
74063 }
74064
74065
74066 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEffectColor(void * jarg1, void * jarg2) {
74067   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74068   Dali::Vector4 *arg2 = 0 ;
74069
74070   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74071   arg2 = (Dali::Vector4 *)jarg2;
74072   if (!arg2) {
74073     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
74074     return ;
74075   }
74076   {
74077     try {
74078       (arg1)->SetOvershootEffectColor((Dali::Vector4 const &)*arg2);
74079     } catch (std::out_of_range& e) {
74080       {
74081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74082       };
74083     } catch (std::exception& e) {
74084       {
74085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74086       };
74087     } catch (Dali::DaliException e) {
74088       {
74089         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74090       };
74091     } catch (...) {
74092       {
74093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74094       };
74095     }
74096   }
74097
74098 }
74099
74100
74101 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootEffectColor(void * jarg1) {
74102   void * jresult ;
74103   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74104   Dali::Vector4 result;
74105
74106   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74107   {
74108     try {
74109       result = ((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootEffectColor();
74110     } catch (std::out_of_range& e) {
74111       {
74112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74113       };
74114     } catch (std::exception& e) {
74115       {
74116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74117       };
74118     } catch (Dali::DaliException e) {
74119       {
74120         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74121       };
74122     } catch (...) {
74123       {
74124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74125       };
74126     }
74127   }
74128
74129   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
74130   return jresult;
74131 }
74132
74133
74134 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootAnimationSpeed(void * jarg1, float jarg2) {
74135   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74136   float arg2 ;
74137
74138   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74139   arg2 = (float)jarg2;
74140   {
74141     try {
74142       (arg1)->SetOvershootAnimationSpeed(arg2);
74143     } catch (std::out_of_range& e) {
74144       {
74145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74146       };
74147     } catch (std::exception& e) {
74148       {
74149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74150       };
74151     } catch (Dali::DaliException e) {
74152       {
74153         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74154       };
74155     } catch (...) {
74156       {
74157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74158       };
74159     }
74160   }
74161
74162 }
74163
74164
74165 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootAnimationSpeed(void * jarg1) {
74166   float jresult ;
74167   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74168   float result;
74169
74170   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74171   {
74172     try {
74173       result = (float)((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootAnimationSpeed();
74174     } catch (std::out_of_range& e) {
74175       {
74176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74177       };
74178     } catch (std::exception& e) {
74179       {
74180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74181       };
74182     } catch (Dali::DaliException e) {
74183       {
74184         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74185       };
74186     } catch (...) {
74187       {
74188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74189       };
74190     }
74191   }
74192
74193   jresult = result;
74194   return jresult;
74195 }
74196
74197
74198 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollStartedSignal(void * jarg1) {
74199   void * jresult ;
74200   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74201   Dali::Toolkit::Scrollable::ScrollStartedSignalType *result = 0 ;
74202
74203   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74204   {
74205     try {
74206       result = (Dali::Toolkit::Scrollable::ScrollStartedSignalType *) &(arg1)->ScrollStartedSignal();
74207     } catch (std::out_of_range& e) {
74208       {
74209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74210       };
74211     } catch (std::exception& e) {
74212       {
74213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74214       };
74215     } catch (Dali::DaliException e) {
74216       {
74217         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74218       };
74219     } catch (...) {
74220       {
74221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74222       };
74223     }
74224   }
74225
74226   jresult = (void *)result;
74227   return jresult;
74228 }
74229
74230
74231 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollUpdatedSignal(void * jarg1) {
74232   void * jresult ;
74233   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74234   Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *result = 0 ;
74235
74236   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74237   {
74238     try {
74239       result = (Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *) &(arg1)->ScrollUpdatedSignal();
74240     } catch (std::out_of_range& e) {
74241       {
74242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74243       };
74244     } catch (std::exception& e) {
74245       {
74246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74247       };
74248     } catch (Dali::DaliException e) {
74249       {
74250         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74251       };
74252     } catch (...) {
74253       {
74254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74255       };
74256     }
74257   }
74258
74259   jresult = (void *)result;
74260   return jresult;
74261 }
74262
74263
74264 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollCompletedSignal(void * jarg1) {
74265   void * jresult ;
74266   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74267   Dali::Toolkit::Scrollable::ScrollCompletedSignalType *result = 0 ;
74268
74269   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74270   {
74271     try {
74272       result = (Dali::Toolkit::Scrollable::ScrollCompletedSignalType *) &(arg1)->ScrollCompletedSignal();
74273     } catch (std::out_of_range& e) {
74274       {
74275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74276       };
74277     } catch (std::exception& e) {
74278       {
74279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74280       };
74281     } catch (Dali::DaliException e) {
74282       {
74283         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74284       };
74285     } catch (...) {
74286       {
74287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74288       };
74289     }
74290   }
74291
74292   jresult = (void *)result;
74293   return jresult;
74294 }
74295
74296
74297 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsVertical(int jarg1) {
74298   unsigned int jresult ;
74299   Dali::Toolkit::ControlOrientation::Type arg1 ;
74300   bool result;
74301
74302   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
74303   {
74304     try {
74305       result = (bool)Dali::Toolkit::IsVertical(arg1);
74306     } catch (std::out_of_range& e) {
74307       {
74308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74309       };
74310     } catch (std::exception& e) {
74311       {
74312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74313       };
74314     } catch (Dali::DaliException e) {
74315       {
74316         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74317       };
74318     } catch (...) {
74319       {
74320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74321       };
74322     }
74323   }
74324
74325   jresult = result;
74326   return jresult;
74327 }
74328
74329
74330 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsHorizontal(int jarg1) {
74331   unsigned int jresult ;
74332   Dali::Toolkit::ControlOrientation::Type arg1 ;
74333   bool result;
74334
74335   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
74336   {
74337     try {
74338       result = (bool)Dali::Toolkit::IsHorizontal(arg1);
74339     } catch (std::out_of_range& e) {
74340       {
74341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74342       };
74343     } catch (std::exception& e) {
74344       {
74345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74346       };
74347     } catch (Dali::DaliException e) {
74348       {
74349         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74350       };
74351     } catch (...) {
74352       {
74353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74354       };
74355     }
74356   }
74357
74358   jresult = result;
74359   return jresult;
74360 }
74361
74362
74363 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_0(unsigned int jarg1, unsigned int jarg2) {
74364   void * jresult ;
74365   unsigned int arg1 ;
74366   unsigned int arg2 ;
74367   Dali::Toolkit::ItemRange *result = 0 ;
74368
74369   arg1 = (unsigned int)jarg1;
74370   arg2 = (unsigned int)jarg2;
74371   {
74372     try {
74373       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange(arg1,arg2);
74374     } catch (std::out_of_range& e) {
74375       {
74376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74377       };
74378     } catch (std::exception& e) {
74379       {
74380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74381       };
74382     } catch (Dali::DaliException e) {
74383       {
74384         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74385       };
74386     } catch (...) {
74387       {
74388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74389       };
74390     }
74391   }
74392
74393   jresult = (void *)result;
74394   return jresult;
74395 }
74396
74397
74398 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_1(void * jarg1) {
74399   void * jresult ;
74400   Dali::Toolkit::ItemRange *arg1 = 0 ;
74401   Dali::Toolkit::ItemRange *result = 0 ;
74402
74403   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74404   if (!arg1) {
74405     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
74406     return 0;
74407   }
74408   {
74409     try {
74410       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange((Dali::Toolkit::ItemRange const &)*arg1);
74411     } catch (std::out_of_range& e) {
74412       {
74413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74414       };
74415     } catch (std::exception& e) {
74416       {
74417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74418       };
74419     } catch (Dali::DaliException e) {
74420       {
74421         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74422       };
74423     } catch (...) {
74424       {
74425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74426       };
74427     }
74428   }
74429
74430   jresult = (void *)result;
74431   return jresult;
74432 }
74433
74434
74435 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Assign(void * jarg1, void * jarg2) {
74436   void * jresult ;
74437   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74438   Dali::Toolkit::ItemRange *arg2 = 0 ;
74439   Dali::Toolkit::ItemRange *result = 0 ;
74440
74441   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74442   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
74443   if (!arg2) {
74444     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
74445     return 0;
74446   }
74447   {
74448     try {
74449       result = (Dali::Toolkit::ItemRange *) &(arg1)->operator =((Dali::Toolkit::ItemRange const &)*arg2);
74450     } catch (std::out_of_range& e) {
74451       {
74452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74453       };
74454     } catch (std::exception& e) {
74455       {
74456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74457       };
74458     } catch (Dali::DaliException e) {
74459       {
74460         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74461       };
74462     } catch (...) {
74463       {
74464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74465       };
74466     }
74467   }
74468
74469   jresult = (void *)result;
74470   return jresult;
74471 }
74472
74473
74474 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_Within(void * jarg1, unsigned int jarg2) {
74475   unsigned int jresult ;
74476   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74477   unsigned int arg2 ;
74478   bool result;
74479
74480   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74481   arg2 = (unsigned int)jarg2;
74482   {
74483     try {
74484       result = (bool)(arg1)->Within(arg2);
74485     } catch (std::out_of_range& e) {
74486       {
74487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74488       };
74489     } catch (std::exception& e) {
74490       {
74491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74492       };
74493     } catch (Dali::DaliException e) {
74494       {
74495         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74496       };
74497     } catch (...) {
74498       {
74499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74500       };
74501     }
74502   }
74503
74504   jresult = result;
74505   return jresult;
74506 }
74507
74508
74509 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Intersection(void * jarg1, void * jarg2) {
74510   void * jresult ;
74511   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74512   Dali::Toolkit::ItemRange *arg2 = 0 ;
74513   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
74514
74515   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74516   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
74517   if (!arg2) {
74518     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
74519     return 0;
74520   }
74521   {
74522     try {
74523       result = (arg1)->Intersection((Dali::Toolkit::ItemRange const &)*arg2);
74524     } catch (std::out_of_range& e) {
74525       {
74526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74527       };
74528     } catch (std::exception& e) {
74529       {
74530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74531       };
74532     } catch (Dali::DaliException e) {
74533       {
74534         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74535       };
74536     } catch (...) {
74537       {
74538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74539       };
74540     }
74541   }
74542
74543   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
74544   return jresult;
74545 }
74546
74547
74548 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_begin_set(void * jarg1, unsigned int jarg2) {
74549   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74550   unsigned int arg2 ;
74551
74552   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74553   arg2 = (unsigned int)jarg2;
74554   if (arg1) (arg1)->begin = arg2;
74555 }
74556
74557
74558 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_begin_get(void * jarg1) {
74559   unsigned int jresult ;
74560   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74561   unsigned int result;
74562
74563   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74564   result = (unsigned int) ((arg1)->begin);
74565   jresult = result;
74566   return jresult;
74567 }
74568
74569
74570 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_end_set(void * jarg1, unsigned int jarg2) {
74571   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74572   unsigned int arg2 ;
74573
74574   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74575   arg2 = (unsigned int)jarg2;
74576   if (arg1) (arg1)->end = arg2;
74577 }
74578
74579
74580 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_end_get(void * jarg1) {
74581   unsigned int jresult ;
74582   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74583   unsigned int result;
74584
74585   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74586   result = (unsigned int) ((arg1)->end);
74587   jresult = result;
74588   return jresult;
74589 }
74590
74591
74592 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemRange(void * jarg1) {
74593   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74594
74595   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74596   {
74597     try {
74598       delete arg1;
74599     } catch (std::out_of_range& e) {
74600       {
74601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74602       };
74603     } catch (std::exception& e) {
74604       {
74605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74606       };
74607     } catch (Dali::DaliException e) {
74608       {
74609         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74610       };
74611     } catch (...) {
74612       {
74613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74614       };
74615     }
74616   }
74617
74618 }
74619
74620
74621 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemLayout(void * jarg1) {
74622   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74623
74624   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74625   {
74626     try {
74627       delete arg1;
74628     } catch (std::out_of_range& e) {
74629       {
74630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74631       };
74632     } catch (std::exception& e) {
74633       {
74634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74635       };
74636     } catch (Dali::DaliException e) {
74637       {
74638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74639       };
74640     } catch (...) {
74641       {
74642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74643       };
74644     }
74645   }
74646
74647 }
74648
74649
74650 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetOrientation(void * jarg1, int jarg2) {
74651   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74652   Dali::Toolkit::ControlOrientation::Type arg2 ;
74653
74654   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74655   arg2 = (Dali::Toolkit::ControlOrientation::Type)jarg2;
74656   {
74657     try {
74658       (arg1)->SetOrientation(arg2);
74659     } catch (std::out_of_range& e) {
74660       {
74661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74662       };
74663     } catch (std::exception& e) {
74664       {
74665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74666       };
74667     } catch (Dali::DaliException e) {
74668       {
74669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74670       };
74671     } catch (...) {
74672       {
74673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74674       };
74675     }
74676   }
74677
74678 }
74679
74680
74681 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetOrientation(void * jarg1) {
74682   int jresult ;
74683   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74684   Dali::Toolkit::ControlOrientation::Type result;
74685
74686   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74687   {
74688     try {
74689       result = (Dali::Toolkit::ControlOrientation::Type)((Dali::Toolkit::ItemLayout const *)arg1)->GetOrientation();
74690     } catch (std::out_of_range& e) {
74691       {
74692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74693       };
74694     } catch (std::exception& e) {
74695       {
74696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74697       };
74698     } catch (Dali::DaliException e) {
74699       {
74700         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74701       };
74702     } catch (...) {
74703       {
74704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74705       };
74706     }
74707   }
74708
74709   jresult = (int)result;
74710   return jresult;
74711 }
74712
74713
74714 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetLayoutProperties(void * jarg1, void * jarg2) {
74715   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74716   Dali::Property::Map *arg2 = 0 ;
74717
74718   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74719   arg2 = (Dali::Property::Map *)jarg2;
74720   if (!arg2) {
74721     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
74722     return ;
74723   }
74724   {
74725     try {
74726       (arg1)->SetLayoutProperties((Dali::Property::Map const &)*arg2);
74727     } catch (std::out_of_range& e) {
74728       {
74729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74730       };
74731     } catch (std::exception& e) {
74732       {
74733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74734       };
74735     } catch (Dali::DaliException e) {
74736       {
74737         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74738       };
74739     } catch (...) {
74740       {
74741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74742       };
74743     }
74744   }
74745
74746 }
74747
74748
74749 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetLayoutProperties(void * jarg1) {
74750   void * jresult ;
74751   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74752   Dali::Property::Map result;
74753
74754   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74755   {
74756     try {
74757       result = (arg1)->GetLayoutProperties();
74758     } catch (std::out_of_range& e) {
74759       {
74760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74761       };
74762     } catch (std::exception& e) {
74763       {
74764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74765       };
74766     } catch (Dali::DaliException e) {
74767       {
74768         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74769       };
74770     } catch (...) {
74771       {
74772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74773       };
74774     }
74775   }
74776
74777   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
74778   return jresult;
74779 }
74780
74781
74782 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
74783   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74784   unsigned int arg2 ;
74785   Dali::Vector3 *arg3 = 0 ;
74786   Dali::Vector3 *arg4 = 0 ;
74787
74788   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74789   arg2 = (unsigned int)jarg2;
74790   arg3 = (Dali::Vector3 *)jarg3;
74791   if (!arg3) {
74792     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
74793     return ;
74794   }
74795   arg4 = (Dali::Vector3 *)jarg4;
74796   if (!arg4) {
74797     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
74798     return ;
74799   }
74800   {
74801     try {
74802       ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
74803     } catch (std::out_of_range& e) {
74804       {
74805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74806       };
74807     } catch (std::exception& e) {
74808       {
74809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74810       };
74811     } catch (Dali::DaliException e) {
74812       {
74813         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74814       };
74815     } catch (...) {
74816       {
74817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74818       };
74819     }
74820   }
74821
74822 }
74823
74824
74825 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetItemSize(void * jarg1, void * jarg2) {
74826   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74827   Dali::Vector3 *arg2 = 0 ;
74828
74829   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74830   arg2 = (Dali::Vector3 *)jarg2;
74831   if (!arg2) {
74832     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
74833     return ;
74834   }
74835   {
74836     try {
74837       (arg1)->SetItemSize((Dali::Vector3 const &)*arg2);
74838     } catch (std::out_of_range& e) {
74839       {
74840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74841       };
74842     } catch (std::exception& e) {
74843       {
74844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74845       };
74846     } catch (Dali::DaliException e) {
74847       {
74848         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74849       };
74850     } catch (...) {
74851       {
74852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74853       };
74854     }
74855   }
74856
74857 }
74858
74859
74860 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMinimumLayoutPosition(void * jarg1, unsigned int jarg2, void * jarg3) {
74861   float jresult ;
74862   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74863   unsigned int arg2 ;
74864   Dali::Vector3 arg3 ;
74865   Dali::Vector3 *argp3 ;
74866   float result;
74867
74868   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74869   arg2 = (unsigned int)jarg2;
74870   argp3 = (Dali::Vector3 *)jarg3;
74871   if (!argp3) {
74872     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
74873     return 0;
74874   }
74875   arg3 = *argp3;
74876   {
74877     try {
74878       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMinimumLayoutPosition(arg2,arg3);
74879     } catch (std::out_of_range& e) {
74880       {
74881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74882       };
74883     } catch (std::exception& e) {
74884       {
74885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74886       };
74887     } catch (Dali::DaliException e) {
74888       {
74889         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74890       };
74891     } catch (...) {
74892       {
74893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74894       };
74895     }
74896   }
74897
74898   jresult = result;
74899   return jresult;
74900 }
74901
74902
74903 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestAnchorPosition(void * jarg1, float jarg2) {
74904   float jresult ;
74905   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74906   float arg2 ;
74907   float result;
74908
74909   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74910   arg2 = (float)jarg2;
74911   {
74912     try {
74913       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetClosestAnchorPosition(arg2);
74914     } catch (std::out_of_range& e) {
74915       {
74916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74917       };
74918     } catch (std::exception& e) {
74919       {
74920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74921       };
74922     } catch (Dali::DaliException e) {
74923       {
74924         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74925       };
74926     } catch (...) {
74927       {
74928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74929       };
74930     }
74931   }
74932
74933   jresult = result;
74934   return jresult;
74935 }
74936
74937
74938 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemScrollToPosition(void * jarg1, unsigned int jarg2) {
74939   float jresult ;
74940   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74941   unsigned int arg2 ;
74942   float result;
74943
74944   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74945   arg2 = (unsigned int)jarg2;
74946   {
74947     try {
74948       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemScrollToPosition(arg2);
74949     } catch (std::out_of_range& e) {
74950       {
74951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74952       };
74953     } catch (std::exception& e) {
74954       {
74955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74956       };
74957     } catch (Dali::DaliException e) {
74958       {
74959         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74960       };
74961     } catch (...) {
74962       {
74963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74964       };
74965     }
74966   }
74967
74968   jresult = result;
74969   return jresult;
74970 }
74971
74972
74973 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemsWithinArea(void * jarg1, float jarg2, void * jarg3) {
74974   void * jresult ;
74975   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74976   float arg2 ;
74977   Dali::Vector3 arg3 ;
74978   Dali::Vector3 *argp3 ;
74979   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
74980
74981   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74982   arg2 = (float)jarg2;
74983   argp3 = (Dali::Vector3 *)jarg3;
74984   if (!argp3) {
74985     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
74986     return 0;
74987   }
74988   arg3 = *argp3;
74989   {
74990     try {
74991       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemsWithinArea(arg2,arg3);
74992     } catch (std::out_of_range& e) {
74993       {
74994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74995       };
74996     } catch (std::exception& e) {
74997       {
74998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74999       };
75000     } catch (Dali::DaliException e) {
75001       {
75002         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75003       };
75004     } catch (...) {
75005       {
75006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75007       };
75008     }
75009   }
75010
75011   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
75012   return jresult;
75013 }
75014
75015
75016 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestOnScreenLayoutPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
75017   float jresult ;
75018   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75019   int arg2 ;
75020   float arg3 ;
75021   Dali::Vector3 *arg4 = 0 ;
75022   float result;
75023
75024   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75025   arg2 = (int)jarg2;
75026   arg3 = (float)jarg3;
75027   arg4 = (Dali::Vector3 *)jarg4;
75028   if (!arg4) {
75029     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
75030     return 0;
75031   }
75032   {
75033     try {
75034       result = (float)(arg1)->GetClosestOnScreenLayoutPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
75035     } catch (std::out_of_range& e) {
75036       {
75037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75038       };
75039     } catch (std::exception& e) {
75040       {
75041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75042       };
75043     } catch (Dali::DaliException e) {
75044       {
75045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75046       };
75047     } catch (...) {
75048       {
75049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75050       };
75051     }
75052   }
75053
75054   jresult = result;
75055   return jresult;
75056 }
75057
75058
75059 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemLayout_GetReserveItemCount(void * jarg1, void * jarg2) {
75060   unsigned int jresult ;
75061   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75062   Dali::Vector3 arg2 ;
75063   Dali::Vector3 *argp2 ;
75064   unsigned int result;
75065
75066   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75067   argp2 = (Dali::Vector3 *)jarg2;
75068   if (!argp2) {
75069     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
75070     return 0;
75071   }
75072   arg2 = *argp2;
75073   {
75074     try {
75075       result = (unsigned int)((Dali::Toolkit::ItemLayout const *)arg1)->GetReserveItemCount(arg2);
75076     } catch (std::out_of_range& e) {
75077       {
75078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75079       };
75080     } catch (std::exception& e) {
75081       {
75082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75083       };
75084     } catch (Dali::DaliException e) {
75085       {
75086         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75087       };
75088     } catch (...) {
75089       {
75090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75091       };
75092     }
75093   }
75094
75095   jresult = result;
75096   return jresult;
75097 }
75098
75099
75100 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetDefaultItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
75101   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75102   unsigned int arg2 ;
75103   Dali::Vector3 *arg3 = 0 ;
75104   Dali::Vector3 *arg4 = 0 ;
75105
75106   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75107   arg2 = (unsigned int)jarg2;
75108   arg3 = (Dali::Vector3 *)jarg3;
75109   if (!arg3) {
75110     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
75111     return ;
75112   }
75113   arg4 = (Dali::Vector3 *)jarg4;
75114   if (!arg4) {
75115     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
75116     return ;
75117   }
75118   {
75119     try {
75120       ((Dali::Toolkit::ItemLayout const *)arg1)->GetDefaultItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
75121     } catch (std::out_of_range& e) {
75122       {
75123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75124       };
75125     } catch (std::exception& e) {
75126       {
75127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75128       };
75129     } catch (Dali::DaliException e) {
75130       {
75131         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75132       };
75133     } catch (...) {
75134       {
75135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75136       };
75137     }
75138   }
75139
75140 }
75141
75142
75143 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollDirection(void * jarg1) {
75144   void * jresult ;
75145   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75146   Dali::Degree result;
75147
75148   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75149   {
75150     try {
75151       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollDirection();
75152     } catch (std::out_of_range& e) {
75153       {
75154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75155       };
75156     } catch (std::exception& e) {
75157       {
75158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75159       };
75160     } catch (Dali::DaliException e) {
75161       {
75162         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75163       };
75164     } catch (...) {
75165       {
75166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75167       };
75168     }
75169   }
75170
75171   jresult = new Dali::Degree((const Dali::Degree &)result);
75172   return jresult;
75173 }
75174
75175
75176 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollSpeedFactor(void * jarg1) {
75177   float jresult ;
75178   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75179   float result;
75180
75181   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75182   {
75183     try {
75184       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollSpeedFactor();
75185     } catch (std::out_of_range& e) {
75186       {
75187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75188       };
75189     } catch (std::exception& e) {
75190       {
75191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75192       };
75193     } catch (Dali::DaliException e) {
75194       {
75195         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75196       };
75197     } catch (...) {
75198       {
75199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75200       };
75201     }
75202   }
75203
75204   jresult = result;
75205   return jresult;
75206 }
75207
75208
75209 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMaximumSwipeSpeed(void * jarg1) {
75210   float jresult ;
75211   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75212   float result;
75213
75214   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75215   {
75216     try {
75217       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMaximumSwipeSpeed();
75218     } catch (std::out_of_range& e) {
75219       {
75220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75221       };
75222     } catch (std::exception& e) {
75223       {
75224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75225       };
75226     } catch (Dali::DaliException e) {
75227       {
75228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75229       };
75230     } catch (...) {
75231       {
75232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75233       };
75234     }
75235   }
75236
75237   jresult = result;
75238   return jresult;
75239 }
75240
75241
75242 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemFlickAnimationDuration(void * jarg1) {
75243   float jresult ;
75244   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75245   float result;
75246
75247   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75248   {
75249     try {
75250       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemFlickAnimationDuration();
75251     } catch (std::out_of_range& e) {
75252       {
75253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75254       };
75255     } catch (std::exception& e) {
75256       {
75257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75258       };
75259     } catch (Dali::DaliException e) {
75260       {
75261         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75262       };
75263     } catch (...) {
75264       {
75265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75266       };
75267     }
75268   }
75269
75270   jresult = result;
75271   return jresult;
75272 }
75273
75274
75275 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetNextFocusItemID(void * jarg1, int jarg2, int jarg3, int jarg4, unsigned int jarg5) {
75276   int jresult ;
75277   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75278   int arg2 ;
75279   int arg3 ;
75280   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
75281   bool arg5 ;
75282   int result;
75283
75284   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75285   arg2 = (int)jarg2;
75286   arg3 = (int)jarg3;
75287   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
75288   arg5 = jarg5 ? true : false;
75289   {
75290     try {
75291       result = (int)(arg1)->GetNextFocusItemID(arg2,arg3,arg4,arg5);
75292     } catch (std::out_of_range& e) {
75293       {
75294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75295       };
75296     } catch (std::exception& e) {
75297       {
75298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75299       };
75300     } catch (Dali::DaliException e) {
75301       {
75302         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75303       };
75304     } catch (...) {
75305       {
75306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75307       };
75308     }
75309   }
75310
75311   jresult = result;
75312   return jresult;
75313 }
75314
75315
75316 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetFlickSpeedFactor(void * jarg1) {
75317   float jresult ;
75318   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75319   float result;
75320
75321   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75322   {
75323     try {
75324       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetFlickSpeedFactor();
75325     } catch (std::out_of_range& e) {
75326       {
75327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75328       };
75329     } catch (std::exception& e) {
75330       {
75331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75332       };
75333     } catch (Dali::DaliException e) {
75334       {
75335         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75336       };
75337     } catch (...) {
75338       {
75339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75340       };
75341     }
75342   }
75343
75344   jresult = result;
75345   return jresult;
75346 }
75347
75348
75349 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_ApplyConstraints(void * jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5) {
75350   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75351   Dali::Actor *arg2 = 0 ;
75352   int arg3 ;
75353   Dali::Vector3 *arg4 = 0 ;
75354   Dali::Actor *arg5 = 0 ;
75355
75356   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75357   arg2 = (Dali::Actor *)jarg2;
75358   if (!arg2) {
75359     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
75360     return ;
75361   }
75362   arg3 = (int)jarg3;
75363   arg4 = (Dali::Vector3 *)jarg4;
75364   if (!arg4) {
75365     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
75366     return ;
75367   }
75368   arg5 = (Dali::Actor *)jarg5;
75369   if (!arg5) {
75370     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
75371     return ;
75372   }
75373   {
75374     try {
75375       (arg1)->ApplyConstraints(*arg2,arg3,(Dali::Vector3 const &)*arg4,(Dali::Actor const &)*arg5);
75376     } catch (std::out_of_range& e) {
75377       {
75378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75379       };
75380     } catch (std::exception& e) {
75381       {
75382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75383       };
75384     } catch (Dali::DaliException e) {
75385       {
75386         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75387       };
75388     } catch (...) {
75389       {
75390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75391       };
75392     }
75393   }
75394
75395 }
75396
75397
75398 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
75399   void * jresult ;
75400   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75401   int arg2 ;
75402   float arg3 ;
75403   Dali::Vector3 *arg4 = 0 ;
75404   Dali::Vector3 result;
75405
75406   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75407   arg2 = (int)jarg2;
75408   arg3 = (float)jarg3;
75409   arg4 = (Dali::Vector3 *)jarg4;
75410   if (!arg4) {
75411     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
75412     return 0;
75413   }
75414   {
75415     try {
75416       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
75417     } catch (std::out_of_range& e) {
75418       {
75419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75420       };
75421     } catch (std::exception& e) {
75422       {
75423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75424       };
75425     } catch (Dali::DaliException e) {
75426       {
75427         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75428       };
75429     } catch (...) {
75430       {
75431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75432       };
75433     }
75434   }
75435
75436   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
75437   return jresult;
75438 }
75439
75440
75441 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NewItemLayout(int jarg1) {
75442   void * jresult ;
75443   Dali::Toolkit::DefaultItemLayout::Type arg1 ;
75444   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
75445
75446   arg1 = (Dali::Toolkit::DefaultItemLayout::Type)jarg1;
75447   {
75448     try {
75449       result = Dali::Toolkit::DefaultItemLayout::New(arg1);
75450     } catch (std::out_of_range& e) {
75451       {
75452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75453       };
75454     } catch (std::exception& e) {
75455       {
75456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75457       };
75458     } catch (Dali::DaliException e) {
75459       {
75460         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75461       };
75462     } catch (...) {
75463       {
75464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75465       };
75466     }
75467   }
75468
75469   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
75470   return jresult;
75471 }
75472
75473
75474 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemFactory(void * jarg1) {
75475   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
75476
75477   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
75478   {
75479     try {
75480       delete arg1;
75481     } catch (std::out_of_range& e) {
75482       {
75483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75484       };
75485     } catch (std::exception& e) {
75486       {
75487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75488       };
75489     } catch (Dali::DaliException e) {
75490       {
75491         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75492       };
75493     } catch (...) {
75494       {
75495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75496       };
75497     }
75498   }
75499
75500 }
75501
75502
75503 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemFactory_GetNumberOfItems(void * jarg1) {
75504   unsigned int jresult ;
75505   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
75506   unsigned int result;
75507
75508   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
75509   {
75510     try {
75511       result = (unsigned int)(arg1)->GetNumberOfItems();
75512     } catch (std::out_of_range& e) {
75513       {
75514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75515       };
75516     } catch (std::exception& e) {
75517       {
75518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75519       };
75520     } catch (Dali::DaliException e) {
75521       {
75522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75523       };
75524     } catch (...) {
75525       {
75526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75527       };
75528     }
75529   }
75530
75531   jresult = result;
75532   return jresult;
75533 }
75534
75535
75536 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemFactory_NewItem(void * jarg1, unsigned int jarg2) {
75537   void * jresult ;
75538   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
75539   unsigned int arg2 ;
75540   Dali::Actor result;
75541
75542   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
75543   arg2 = (unsigned int)jarg2;
75544   {
75545     try {
75546       result = (arg1)->NewItem(arg2);
75547     } catch (std::out_of_range& e) {
75548       {
75549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75550       };
75551     } catch (std::exception& e) {
75552       {
75553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75554       };
75555     } catch (Dali::DaliException e) {
75556       {
75557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75558       };
75559     } catch (...) {
75560       {
75561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75562       };
75563     }
75564   }
75565
75566   jresult = new Dali::Actor((const Dali::Actor &)result);
75567   return jresult;
75568 }
75569
75570
75571 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleased(void * jarg1, unsigned int jarg2, void * jarg3) {
75572   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
75573   unsigned int arg2 ;
75574   Dali::Actor arg3 ;
75575   Dali::Actor *argp3 ;
75576
75577   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
75578   arg2 = (unsigned int)jarg2;
75579   argp3 = (Dali::Actor *)jarg3;
75580   if (!argp3) {
75581     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
75582     return ;
75583   }
75584   arg3 = *argp3;
75585   {
75586     try {
75587       (arg1)->ItemReleased(arg2,arg3);
75588     } catch (std::out_of_range& e) {
75589       {
75590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75591       };
75592     } catch (std::exception& e) {
75593       {
75594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75595       };
75596     } catch (Dali::DaliException e) {
75597       {
75598         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75599       };
75600     } catch (...) {
75601       {
75602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75603       };
75604     }
75605   }
75606
75607 }
75608
75609
75610 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleasedSwigExplicitItemFactory(void * jarg1, unsigned int jarg2, void * jarg3) {
75611   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
75612   unsigned int arg2 ;
75613   Dali::Actor arg3 ;
75614   Dali::Actor *argp3 ;
75615
75616   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
75617   arg2 = (unsigned int)jarg2;
75618   argp3 = (Dali::Actor *)jarg3;
75619   if (!argp3) {
75620     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
75621     return ;
75622   }
75623   arg3 = *argp3;
75624   {
75625     try {
75626       (arg1)->Dali::Toolkit::ItemFactory::ItemReleased(arg2,arg3);
75627     } catch (std::out_of_range& e) {
75628       {
75629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75630       };
75631     } catch (std::exception& e) {
75632       {
75633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75634       };
75635     } catch (Dali::DaliException e) {
75636       {
75637         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75638       };
75639     } catch (...) {
75640       {
75641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75642       };
75643     }
75644   }
75645
75646 }
75647
75648
75649 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemFactory() {
75650   void * jresult ;
75651   Dali::Toolkit::ItemFactory *result = 0 ;
75652
75653   {
75654     try {
75655       result = (Dali::Toolkit::ItemFactory *)new SwigDirector_ItemFactory();
75656     } catch (std::out_of_range& e) {
75657       {
75658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75659       };
75660     } catch (std::exception& e) {
75661       {
75662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75663       };
75664     } catch (Dali::DaliException e) {
75665       {
75666         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75667       };
75668     } catch (...) {
75669       {
75670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75671       };
75672     }
75673   }
75674
75675   jresult = (void *)result;
75676   return jresult;
75677 }
75678
75679
75680 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) {
75681   Dali::Toolkit::ItemFactory *obj = (Dali::Toolkit::ItemFactory *)objarg;
75682   SwigDirector_ItemFactory *director = dynamic_cast<SwigDirector_ItemFactory *>(obj);
75683   if (director) {
75684     director->swig_connect_director(callback0, callback1, callback2);
75685   }
75686 }
75687
75688
75689 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_SPEED_get() {
75690   int jresult ;
75691   int result;
75692
75693   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_SPEED;
75694   jresult = (int)result;
75695   return jresult;
75696 }
75697
75698
75699 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_DISTANCE_get() {
75700   int jresult ;
75701   int result;
75702
75703   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_DISTANCE;
75704   jresult = (int)result;
75705   return jresult;
75706 }
75707
75708
75709 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
75710   int jresult ;
75711   int result;
75712
75713   result = (int)Dali::Toolkit::ItemView::Property::WHEEL_SCROLL_DISTANCE_STEP;
75714   jresult = (int)result;
75715   return jresult;
75716 }
75717
75718
75719 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SNAP_TO_ITEM_ENABLED_get() {
75720   int jresult ;
75721   int result;
75722
75723   result = (int)Dali::Toolkit::ItemView::Property::SNAP_TO_ITEM_ENABLED;
75724   jresult = (int)result;
75725   return jresult;
75726 }
75727
75728
75729 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_REFRESH_INTERVAL_get() {
75730   int jresult ;
75731   int result;
75732
75733   result = (int)Dali::Toolkit::ItemView::Property::REFRESH_INTERVAL;
75734   jresult = (int)result;
75735   return jresult;
75736 }
75737
75738
75739 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_POSITION_get() {
75740   int jresult ;
75741   int result;
75742
75743   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_POSITION;
75744   jresult = (int)result;
75745   return jresult;
75746 }
75747
75748
75749 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_SPEED_get() {
75750   int jresult ;
75751   int result;
75752
75753   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_SPEED;
75754   jresult = (int)result;
75755   return jresult;
75756 }
75757
75758
75759 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_OVERSHOOT_get() {
75760   int jresult ;
75761   int result;
75762
75763   result = (int)Dali::Toolkit::ItemView::Property::OVERSHOOT;
75764   jresult = (int)result;
75765   return jresult;
75766 }
75767
75768
75769 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_DIRECTION_get() {
75770   int jresult ;
75771   int result;
75772
75773   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_DIRECTION;
75774   jresult = (int)result;
75775   return jresult;
75776 }
75777
75778
75779 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_ORIENTATION_get() {
75780   int jresult ;
75781   int result;
75782
75783   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_ORIENTATION;
75784   jresult = (int)result;
75785   return jresult;
75786 }
75787
75788
75789 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_CONTENT_SIZE_get() {
75790   int jresult ;
75791   int result;
75792
75793   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_CONTENT_SIZE;
75794   jresult = (int)result;
75795   return jresult;
75796 }
75797
75798
75799 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView_Property() {
75800   void * jresult ;
75801   Dali::Toolkit::ItemView::Property *result = 0 ;
75802
75803   {
75804     try {
75805       result = (Dali::Toolkit::ItemView::Property *)new Dali::Toolkit::ItemView::Property();
75806     } catch (std::out_of_range& e) {
75807       {
75808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75809       };
75810     } catch (std::exception& e) {
75811       {
75812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75813       };
75814     } catch (Dali::DaliException e) {
75815       {
75816         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75817       };
75818     } catch (...) {
75819       {
75820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75821       };
75822     }
75823   }
75824
75825   jresult = (void *)result;
75826   return jresult;
75827 }
75828
75829
75830 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView_Property(void * jarg1) {
75831   Dali::Toolkit::ItemView::Property *arg1 = (Dali::Toolkit::ItemView::Property *) 0 ;
75832
75833   arg1 = (Dali::Toolkit::ItemView::Property *)jarg1;
75834   {
75835     try {
75836       delete arg1;
75837     } catch (std::out_of_range& e) {
75838       {
75839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75840       };
75841     } catch (std::exception& e) {
75842       {
75843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75844       };
75845     } catch (Dali::DaliException e) {
75846       {
75847         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75848       };
75849     } catch (...) {
75850       {
75851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75852       };
75853     }
75854   }
75855
75856 }
75857
75858
75859 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_0() {
75860   void * jresult ;
75861   Dali::Toolkit::ItemView *result = 0 ;
75862
75863   {
75864     try {
75865       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView();
75866     } catch (std::out_of_range& e) {
75867       {
75868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75869       };
75870     } catch (std::exception& e) {
75871       {
75872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75873       };
75874     } catch (Dali::DaliException e) {
75875       {
75876         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75877       };
75878     } catch (...) {
75879       {
75880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75881       };
75882     }
75883   }
75884
75885   jresult = (void *)result;
75886   return jresult;
75887 }
75888
75889
75890 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_1(void * jarg1) {
75891   void * jresult ;
75892   Dali::Toolkit::ItemView *arg1 = 0 ;
75893   Dali::Toolkit::ItemView *result = 0 ;
75894
75895   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75896   if (!arg1) {
75897     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
75898     return 0;
75899   }
75900   {
75901     try {
75902       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView((Dali::Toolkit::ItemView const &)*arg1);
75903     } catch (std::out_of_range& e) {
75904       {
75905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75906       };
75907     } catch (std::exception& e) {
75908       {
75909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75910       };
75911     } catch (Dali::DaliException e) {
75912       {
75913         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75914       };
75915     } catch (...) {
75916       {
75917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75918       };
75919     }
75920   }
75921
75922   jresult = (void *)result;
75923   return jresult;
75924 }
75925
75926
75927 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_Assign(void * jarg1, void * jarg2) {
75928   void * jresult ;
75929   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75930   Dali::Toolkit::ItemView *arg2 = 0 ;
75931   Dali::Toolkit::ItemView *result = 0 ;
75932
75933   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75934   arg2 = (Dali::Toolkit::ItemView *)jarg2;
75935   if (!arg2) {
75936     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
75937     return 0;
75938   }
75939   {
75940     try {
75941       result = (Dali::Toolkit::ItemView *) &(arg1)->operator =((Dali::Toolkit::ItemView const &)*arg2);
75942     } catch (std::out_of_range& e) {
75943       {
75944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75945       };
75946     } catch (std::exception& e) {
75947       {
75948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75949       };
75950     } catch (Dali::DaliException e) {
75951       {
75952         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75953       };
75954     } catch (...) {
75955       {
75956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75957       };
75958     }
75959   }
75960
75961   jresult = (void *)result;
75962   return jresult;
75963 }
75964
75965
75966 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView(void * jarg1) {
75967   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75968
75969   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75970   {
75971     try {
75972       delete arg1;
75973     } catch (std::out_of_range& e) {
75974       {
75975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75976       };
75977     } catch (std::exception& e) {
75978       {
75979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75980       };
75981     } catch (Dali::DaliException e) {
75982       {
75983         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75984       };
75985     } catch (...) {
75986       {
75987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75988       };
75989     }
75990   }
75991
75992 }
75993
75994
75995 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_New(void * jarg1) {
75996   void * jresult ;
75997   Dali::Toolkit::ItemFactory *arg1 = 0 ;
75998   Dali::Toolkit::ItemView result;
75999
76000   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
76001   if (!arg1) {
76002     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemFactory & type is null", 0);
76003     return 0;
76004   }
76005   {
76006     try {
76007       result = Dali::Toolkit::ItemView::New(*arg1);
76008     } catch (std::out_of_range& e) {
76009       {
76010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76011       };
76012     } catch (std::exception& e) {
76013       {
76014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76015       };
76016     } catch (Dali::DaliException e) {
76017       {
76018         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76019       };
76020     } catch (...) {
76021       {
76022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76023       };
76024     }
76025   }
76026
76027   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
76028   return jresult;
76029 }
76030
76031
76032 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_DownCast(void * jarg1) {
76033   void * jresult ;
76034   Dali::BaseHandle arg1 ;
76035   Dali::BaseHandle *argp1 ;
76036   Dali::Toolkit::ItemView result;
76037
76038   argp1 = (Dali::BaseHandle *)jarg1;
76039   if (!argp1) {
76040     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
76041     return 0;
76042   }
76043   arg1 = *argp1;
76044   {
76045     try {
76046       result = Dali::Toolkit::ItemView::DownCast(arg1);
76047     } catch (std::out_of_range& e) {
76048       {
76049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76050       };
76051     } catch (std::exception& e) {
76052       {
76053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76054       };
76055     } catch (Dali::DaliException e) {
76056       {
76057         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76058       };
76059     } catch (...) {
76060       {
76061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76062       };
76063     }
76064   }
76065
76066   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
76067   return jresult;
76068 }
76069
76070
76071 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetLayoutCount(void * jarg1) {
76072   unsigned int jresult ;
76073   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76074   unsigned int result;
76075
76076   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76077   {
76078     try {
76079       result = (unsigned int)((Dali::Toolkit::ItemView const *)arg1)->GetLayoutCount();
76080     } catch (std::out_of_range& e) {
76081       {
76082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76083       };
76084     } catch (std::exception& e) {
76085       {
76086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76087       };
76088     } catch (Dali::DaliException e) {
76089       {
76090         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76091       };
76092     } catch (...) {
76093       {
76094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76095       };
76096     }
76097   }
76098
76099   jresult = result;
76100   return jresult;
76101 }
76102
76103
76104 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_AddLayout(void * jarg1, void * jarg2) {
76105   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76106   Dali::Toolkit::ItemLayout *arg2 = 0 ;
76107
76108   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76109   arg2 = (Dali::Toolkit::ItemLayout *)jarg2;
76110   if (!arg2) {
76111     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemLayout & type is null", 0);
76112     return ;
76113   }
76114   {
76115     try {
76116       (arg1)->AddLayout(*arg2);
76117     } catch (std::out_of_range& e) {
76118       {
76119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76120       };
76121     } catch (std::exception& e) {
76122       {
76123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76124       };
76125     } catch (Dali::DaliException e) {
76126       {
76127         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76128       };
76129     } catch (...) {
76130       {
76131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76132       };
76133     }
76134   }
76135
76136 }
76137
76138
76139 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveLayout(void * jarg1, unsigned int jarg2) {
76140   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76141   unsigned int arg2 ;
76142
76143   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76144   arg2 = (unsigned int)jarg2;
76145   {
76146     try {
76147       (arg1)->RemoveLayout(arg2);
76148     } catch (std::out_of_range& e) {
76149       {
76150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76151       };
76152     } catch (std::exception& e) {
76153       {
76154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76155       };
76156     } catch (Dali::DaliException e) {
76157       {
76158         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76159       };
76160     } catch (...) {
76161       {
76162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76163       };
76164     }
76165   }
76166
76167 }
76168
76169
76170 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetLayout(void * jarg1, unsigned int jarg2) {
76171   void * jresult ;
76172   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76173   unsigned int arg2 ;
76174   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
76175
76176   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76177   arg2 = (unsigned int)jarg2;
76178   {
76179     try {
76180       result = ((Dali::Toolkit::ItemView const *)arg1)->GetLayout(arg2);
76181     } catch (std::out_of_range& e) {
76182       {
76183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76184       };
76185     } catch (std::exception& e) {
76186       {
76187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76188       };
76189     } catch (Dali::DaliException e) {
76190       {
76191         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76192       };
76193     } catch (...) {
76194       {
76195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76196       };
76197     }
76198   }
76199
76200   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
76201   return jresult;
76202 }
76203
76204
76205 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetActiveLayout(void * jarg1) {
76206   void * jresult ;
76207   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76208   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
76209
76210   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76211   {
76212     try {
76213       result = ((Dali::Toolkit::ItemView const *)arg1)->GetActiveLayout();
76214     } catch (std::out_of_range& e) {
76215       {
76216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76217       };
76218     } catch (std::exception& e) {
76219       {
76220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76221       };
76222     } catch (Dali::DaliException e) {
76223       {
76224         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76225       };
76226     } catch (...) {
76227       {
76228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76229       };
76230     }
76231   }
76232
76233   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
76234   return jresult;
76235 }
76236
76237
76238 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetCurrentLayoutPosition(void * jarg1, unsigned int jarg2) {
76239   float jresult ;
76240   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76241   Dali::Toolkit::ItemId arg2 ;
76242   float result;
76243
76244   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76245   arg2 = (Dali::Toolkit::ItemId)jarg2;
76246   {
76247     try {
76248       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetCurrentLayoutPosition(arg2);
76249     } catch (std::out_of_range& e) {
76250       {
76251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76252       };
76253     } catch (std::exception& e) {
76254       {
76255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76256       };
76257     } catch (Dali::DaliException e) {
76258       {
76259         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76260       };
76261     } catch (...) {
76262       {
76263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76264       };
76265     }
76266   }
76267
76268   jresult = result;
76269   return jresult;
76270 }
76271
76272
76273 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ActivateLayout(void * jarg1, unsigned int jarg2, void * jarg3, float jarg4) {
76274   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76275   unsigned int arg2 ;
76276   Dali::Vector3 arg3 ;
76277   float arg4 ;
76278   Dali::Vector3 *argp3 ;
76279
76280   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76281   arg2 = (unsigned int)jarg2;
76282   argp3 = (Dali::Vector3 *)jarg3;
76283   if (!argp3) {
76284     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
76285     return ;
76286   }
76287   arg3 = *argp3;
76288   arg4 = (float)jarg4;
76289   {
76290     try {
76291       (arg1)->ActivateLayout(arg2,arg3,arg4);
76292     } catch (std::out_of_range& e) {
76293       {
76294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76295       };
76296     } catch (std::exception& e) {
76297       {
76298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76299       };
76300     } catch (Dali::DaliException e) {
76301       {
76302         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76303       };
76304     } catch (...) {
76305       {
76306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76307       };
76308     }
76309   }
76310
76311 }
76312
76313
76314 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_DeactivateCurrentLayout(void * jarg1) {
76315   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76316
76317   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76318   {
76319     try {
76320       (arg1)->DeactivateCurrentLayout();
76321     } catch (std::out_of_range& e) {
76322       {
76323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76324       };
76325     } catch (std::exception& e) {
76326       {
76327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76328       };
76329     } catch (Dali::DaliException e) {
76330       {
76331         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76332       };
76333     } catch (...) {
76334       {
76335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76336       };
76337     }
76338   }
76339
76340 }
76341
76342
76343 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeSpeed(void * jarg1, float jarg2) {
76344   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76345   float arg2 ;
76346
76347   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76348   arg2 = (float)jarg2;
76349   {
76350     try {
76351       (arg1)->SetMinimumSwipeSpeed(arg2);
76352     } catch (std::out_of_range& e) {
76353       {
76354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76355       };
76356     } catch (std::exception& e) {
76357       {
76358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76359       };
76360     } catch (Dali::DaliException e) {
76361       {
76362         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76363       };
76364     } catch (...) {
76365       {
76366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76367       };
76368     }
76369   }
76370
76371 }
76372
76373
76374 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeSpeed(void * jarg1) {
76375   float jresult ;
76376   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76377   float result;
76378
76379   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76380   {
76381     try {
76382       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeSpeed();
76383     } catch (std::out_of_range& e) {
76384       {
76385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76386       };
76387     } catch (std::exception& e) {
76388       {
76389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76390       };
76391     } catch (Dali::DaliException e) {
76392       {
76393         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76394       };
76395     } catch (...) {
76396       {
76397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76398       };
76399     }
76400   }
76401
76402   jresult = result;
76403   return jresult;
76404 }
76405
76406
76407 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeDistance(void * jarg1, float jarg2) {
76408   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76409   float arg2 ;
76410
76411   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76412   arg2 = (float)jarg2;
76413   {
76414     try {
76415       (arg1)->SetMinimumSwipeDistance(arg2);
76416     } catch (std::out_of_range& e) {
76417       {
76418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76419       };
76420     } catch (std::exception& e) {
76421       {
76422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76423       };
76424     } catch (Dali::DaliException e) {
76425       {
76426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76427       };
76428     } catch (...) {
76429       {
76430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76431       };
76432     }
76433   }
76434
76435 }
76436
76437
76438 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeDistance(void * jarg1) {
76439   float jresult ;
76440   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76441   float result;
76442
76443   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76444   {
76445     try {
76446       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeDistance();
76447     } catch (std::out_of_range& e) {
76448       {
76449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76450       };
76451     } catch (std::exception& e) {
76452       {
76453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76454       };
76455     } catch (Dali::DaliException e) {
76456       {
76457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76458       };
76459     } catch (...) {
76460       {
76461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76462       };
76463     }
76464   }
76465
76466   jresult = result;
76467   return jresult;
76468 }
76469
76470
76471 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetWheelScrollDistanceStep(void * jarg1, float jarg2) {
76472   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76473   float arg2 ;
76474
76475   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76476   arg2 = (float)jarg2;
76477   {
76478     try {
76479       (arg1)->SetWheelScrollDistanceStep(arg2);
76480     } catch (std::out_of_range& e) {
76481       {
76482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76483       };
76484     } catch (std::exception& e) {
76485       {
76486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76487       };
76488     } catch (Dali::DaliException e) {
76489       {
76490         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76491       };
76492     } catch (...) {
76493       {
76494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76495       };
76496     }
76497   }
76498
76499 }
76500
76501
76502 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetWheelScrollDistanceStep(void * jarg1) {
76503   float jresult ;
76504   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76505   float result;
76506
76507   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76508   {
76509     try {
76510       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetWheelScrollDistanceStep();
76511     } catch (std::out_of_range& e) {
76512       {
76513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76514       };
76515     } catch (std::exception& e) {
76516       {
76517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76518       };
76519     } catch (Dali::DaliException e) {
76520       {
76521         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76522       };
76523     } catch (...) {
76524       {
76525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76526       };
76527     }
76528   }
76529
76530   jresult = result;
76531   return jresult;
76532 }
76533
76534
76535 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoring(void * jarg1, unsigned int jarg2) {
76536   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76537   bool arg2 ;
76538
76539   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76540   arg2 = jarg2 ? true : false;
76541   {
76542     try {
76543       (arg1)->SetAnchoring(arg2);
76544     } catch (std::out_of_range& e) {
76545       {
76546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76547       };
76548     } catch (std::exception& e) {
76549       {
76550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76551       };
76552     } catch (Dali::DaliException e) {
76553       {
76554         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76555       };
76556     } catch (...) {
76557       {
76558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76559       };
76560     }
76561   }
76562
76563 }
76564
76565 //// ========================= end of part 3 =============================
76566
76567 //// ========================== start part 4 ===============================
76568
76569
76570 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoring(void * jarg1) {
76571   unsigned int jresult ;
76572   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76573   bool result;
76574
76575   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76576   {
76577     try {
76578       result = (bool)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoring();
76579     } catch (std::out_of_range& e) {
76580       {
76581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76582       };
76583     } catch (std::exception& e) {
76584       {
76585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76586       };
76587     } catch (Dali::DaliException e) {
76588       {
76589         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76590       };
76591     } catch (...) {
76592       {
76593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76594       };
76595     }
76596   }
76597
76598   jresult = result;
76599   return jresult;
76600 }
76601
76602
76603 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoringDuration(void * jarg1, float jarg2) {
76604   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76605   float arg2 ;
76606
76607   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76608   arg2 = (float)jarg2;
76609   {
76610     try {
76611       (arg1)->SetAnchoringDuration(arg2);
76612     } catch (std::out_of_range& e) {
76613       {
76614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76615       };
76616     } catch (std::exception& e) {
76617       {
76618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76619       };
76620     } catch (Dali::DaliException e) {
76621       {
76622         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76623       };
76624     } catch (...) {
76625       {
76626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76627       };
76628     }
76629   }
76630
76631 }
76632
76633
76634 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoringDuration(void * jarg1) {
76635   float jresult ;
76636   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76637   float result;
76638
76639   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76640   {
76641     try {
76642       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoringDuration();
76643     } catch (std::out_of_range& e) {
76644       {
76645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76646       };
76647     } catch (std::exception& e) {
76648       {
76649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76650       };
76651     } catch (Dali::DaliException e) {
76652       {
76653         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76654       };
76655     } catch (...) {
76656       {
76657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76658       };
76659     }
76660   }
76661
76662   jresult = result;
76663   return jresult;
76664 }
76665
76666
76667 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ScrollToItem(void * jarg1, unsigned int jarg2, float jarg3) {
76668   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76669   Dali::Toolkit::ItemId arg2 ;
76670   float arg3 ;
76671
76672   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76673   arg2 = (Dali::Toolkit::ItemId)jarg2;
76674   arg3 = (float)jarg3;
76675   {
76676     try {
76677       (arg1)->ScrollToItem(arg2,arg3);
76678     } catch (std::out_of_range& e) {
76679       {
76680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76681       };
76682     } catch (std::exception& e) {
76683       {
76684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76685       };
76686     } catch (Dali::DaliException e) {
76687       {
76688         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76689       };
76690     } catch (...) {
76691       {
76692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76693       };
76694     }
76695   }
76696
76697 }
76698
76699
76700 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetRefreshInterval(void * jarg1, float jarg2) {
76701   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76702   float arg2 ;
76703
76704   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76705   arg2 = (float)jarg2;
76706   {
76707     try {
76708       (arg1)->SetRefreshInterval(arg2);
76709     } catch (std::out_of_range& e) {
76710       {
76711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76712       };
76713     } catch (std::exception& e) {
76714       {
76715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76716       };
76717     } catch (Dali::DaliException e) {
76718       {
76719         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76720       };
76721     } catch (...) {
76722       {
76723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76724       };
76725     }
76726   }
76727
76728 }
76729
76730
76731 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetRefreshInterval(void * jarg1) {
76732   float jresult ;
76733   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76734   float result;
76735
76736   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76737   {
76738     try {
76739       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetRefreshInterval();
76740     } catch (std::out_of_range& e) {
76741       {
76742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76743       };
76744     } catch (std::exception& e) {
76745       {
76746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76747       };
76748     } catch (Dali::DaliException e) {
76749       {
76750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76751       };
76752     } catch (...) {
76753       {
76754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76755       };
76756     }
76757   }
76758
76759   jresult = result;
76760   return jresult;
76761 }
76762
76763
76764 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_Refresh(void * jarg1) {
76765   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76766
76767   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76768   {
76769     try {
76770       (arg1)->Refresh();
76771     } catch (std::out_of_range& e) {
76772       {
76773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76774       };
76775     } catch (std::exception& e) {
76776       {
76777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76778       };
76779     } catch (Dali::DaliException e) {
76780       {
76781         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76782       };
76783     } catch (...) {
76784       {
76785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76786       };
76787     }
76788   }
76789
76790 }
76791
76792
76793 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItem(void * jarg1, unsigned int jarg2) {
76794   void * jresult ;
76795   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76796   Dali::Toolkit::ItemId arg2 ;
76797   Dali::Actor result;
76798
76799   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76800   arg2 = (Dali::Toolkit::ItemId)jarg2;
76801   {
76802     try {
76803       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItem(arg2);
76804     } catch (std::out_of_range& e) {
76805       {
76806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76807       };
76808     } catch (std::exception& e) {
76809       {
76810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76811       };
76812     } catch (Dali::DaliException e) {
76813       {
76814         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76815       };
76816     } catch (...) {
76817       {
76818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76819       };
76820     }
76821   }
76822
76823   jresult = new Dali::Actor((const Dali::Actor &)result);
76824   return jresult;
76825 }
76826
76827
76828 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetItemId(void * jarg1, void * jarg2) {
76829   unsigned int jresult ;
76830   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76831   Dali::Actor arg2 ;
76832   Dali::Actor *argp2 ;
76833   Dali::Toolkit::ItemId result;
76834
76835   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76836   argp2 = (Dali::Actor *)jarg2;
76837   if (!argp2) {
76838     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
76839     return 0;
76840   }
76841   arg2 = *argp2;
76842   {
76843     try {
76844       result = (Dali::Toolkit::ItemId)((Dali::Toolkit::ItemView const *)arg1)->GetItemId(arg2);
76845     } catch (std::out_of_range& e) {
76846       {
76847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76848       };
76849     } catch (std::exception& e) {
76850       {
76851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76852       };
76853     } catch (Dali::DaliException e) {
76854       {
76855         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76856       };
76857     } catch (...) {
76858       {
76859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76860       };
76861     }
76862   }
76863
76864   jresult = result;
76865   return jresult;
76866 }
76867
76868
76869 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItem(void * jarg1, void * jarg2, float jarg3) {
76870   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76871   Dali::Toolkit::Item arg2 ;
76872   float arg3 ;
76873   Dali::Toolkit::Item *argp2 ;
76874
76875   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76876   argp2 = (Dali::Toolkit::Item *)jarg2;
76877   if (!argp2) {
76878     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
76879     return ;
76880   }
76881   arg2 = *argp2;
76882   arg3 = (float)jarg3;
76883   {
76884     try {
76885       (arg1)->InsertItem(arg2,arg3);
76886     } catch (std::out_of_range& e) {
76887       {
76888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76889       };
76890     } catch (std::exception& e) {
76891       {
76892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76893       };
76894     } catch (Dali::DaliException e) {
76895       {
76896         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76897       };
76898     } catch (...) {
76899       {
76900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76901       };
76902     }
76903   }
76904
76905 }
76906
76907
76908 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItems(void * jarg1, void * jarg2, float jarg3) {
76909   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76910   Dali::Toolkit::ItemContainer *arg2 = 0 ;
76911   float arg3 ;
76912
76913   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76914   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
76915   if (!arg2) {
76916     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
76917     return ;
76918   }
76919   arg3 = (float)jarg3;
76920   {
76921     try {
76922       (arg1)->InsertItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
76923     } catch (std::out_of_range& e) {
76924       {
76925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76926       };
76927     } catch (std::exception& e) {
76928       {
76929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76930       };
76931     } catch (Dali::DaliException e) {
76932       {
76933         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76934       };
76935     } catch (...) {
76936       {
76937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76938       };
76939     }
76940   }
76941
76942 }
76943
76944
76945 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItem(void * jarg1, unsigned int jarg2, float jarg3) {
76946   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76947   Dali::Toolkit::ItemId arg2 ;
76948   float arg3 ;
76949
76950   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76951   arg2 = (Dali::Toolkit::ItemId)jarg2;
76952   arg3 = (float)jarg3;
76953   {
76954     try {
76955       (arg1)->RemoveItem(arg2,arg3);
76956     } catch (std::out_of_range& e) {
76957       {
76958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76959       };
76960     } catch (std::exception& e) {
76961       {
76962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76963       };
76964     } catch (Dali::DaliException e) {
76965       {
76966         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76967       };
76968     } catch (...) {
76969       {
76970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76971       };
76972     }
76973   }
76974
76975 }
76976
76977
76978 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItems(void * jarg1, void * jarg2, float jarg3) {
76979   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76980   Dali::Toolkit::ItemIdContainer *arg2 = 0 ;
76981   float arg3 ;
76982
76983   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76984   arg2 = (Dali::Toolkit::ItemIdContainer *)jarg2;
76985   if (!arg2) {
76986     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemIdContainer const & type is null", 0);
76987     return ;
76988   }
76989   arg3 = (float)jarg3;
76990   {
76991     try {
76992       (arg1)->RemoveItems((Dali::Toolkit::ItemIdContainer const &)*arg2,arg3);
76993     } catch (std::out_of_range& e) {
76994       {
76995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76996       };
76997     } catch (std::exception& e) {
76998       {
76999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77000       };
77001     } catch (Dali::DaliException e) {
77002       {
77003         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77004       };
77005     } catch (...) {
77006       {
77007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77008       };
77009     }
77010   }
77011
77012 }
77013
77014
77015 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItem(void * jarg1, void * jarg2, float jarg3) {
77016   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77017   Dali::Toolkit::Item arg2 ;
77018   float arg3 ;
77019   Dali::Toolkit::Item *argp2 ;
77020
77021   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77022   argp2 = (Dali::Toolkit::Item *)jarg2;
77023   if (!argp2) {
77024     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
77025     return ;
77026   }
77027   arg2 = *argp2;
77028   arg3 = (float)jarg3;
77029   {
77030     try {
77031       (arg1)->ReplaceItem(arg2,arg3);
77032     } catch (std::out_of_range& e) {
77033       {
77034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77035       };
77036     } catch (std::exception& e) {
77037       {
77038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77039       };
77040     } catch (Dali::DaliException e) {
77041       {
77042         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77043       };
77044     } catch (...) {
77045       {
77046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77047       };
77048     }
77049   }
77050
77051 }
77052
77053
77054 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItems(void * jarg1, void * jarg2, float jarg3) {
77055   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77056   Dali::Toolkit::ItemContainer *arg2 = 0 ;
77057   float arg3 ;
77058
77059   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77060   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
77061   if (!arg2) {
77062     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
77063     return ;
77064   }
77065   arg3 = (float)jarg3;
77066   {
77067     try {
77068       (arg1)->ReplaceItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
77069     } catch (std::out_of_range& e) {
77070       {
77071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77072       };
77073     } catch (std::exception& e) {
77074       {
77075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77076       };
77077     } catch (Dali::DaliException e) {
77078       {
77079         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77080       };
77081     } catch (...) {
77082       {
77083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77084       };
77085     }
77086   }
77087
77088 }
77089
77090
77091 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsParentOrigin(void * jarg1, void * jarg2) {
77092   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77093   Dali::Vector3 *arg2 = 0 ;
77094
77095   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77096   arg2 = (Dali::Vector3 *)jarg2;
77097   if (!arg2) {
77098     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
77099     return ;
77100   }
77101   {
77102     try {
77103       (arg1)->SetItemsParentOrigin((Dali::Vector3 const &)*arg2);
77104     } catch (std::out_of_range& e) {
77105       {
77106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77107       };
77108     } catch (std::exception& e) {
77109       {
77110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77111       };
77112     } catch (Dali::DaliException e) {
77113       {
77114         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77115       };
77116     } catch (...) {
77117       {
77118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77119       };
77120     }
77121   }
77122
77123 }
77124
77125
77126 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsParentOrigin(void * jarg1) {
77127   void * jresult ;
77128   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77129   Dali::Vector3 result;
77130
77131   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77132   {
77133     try {
77134       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsParentOrigin();
77135     } catch (std::out_of_range& e) {
77136       {
77137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77138       };
77139     } catch (std::exception& e) {
77140       {
77141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77142       };
77143     } catch (Dali::DaliException e) {
77144       {
77145         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77146       };
77147     } catch (...) {
77148       {
77149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77150       };
77151     }
77152   }
77153
77154   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
77155   return jresult;
77156 }
77157
77158
77159 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsAnchorPoint(void * jarg1, void * jarg2) {
77160   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77161   Dali::Vector3 *arg2 = 0 ;
77162
77163   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77164   arg2 = (Dali::Vector3 *)jarg2;
77165   if (!arg2) {
77166     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
77167     return ;
77168   }
77169   {
77170     try {
77171       (arg1)->SetItemsAnchorPoint((Dali::Vector3 const &)*arg2);
77172     } catch (std::out_of_range& e) {
77173       {
77174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77175       };
77176     } catch (std::exception& e) {
77177       {
77178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77179       };
77180     } catch (Dali::DaliException e) {
77181       {
77182         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77183       };
77184     } catch (...) {
77185       {
77186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77187       };
77188     }
77189   }
77190
77191 }
77192
77193
77194 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsAnchorPoint(void * jarg1) {
77195   void * jresult ;
77196   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77197   Dali::Vector3 result;
77198
77199   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77200   {
77201     try {
77202       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsAnchorPoint();
77203     } catch (std::out_of_range& e) {
77204       {
77205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77206       };
77207     } catch (std::exception& e) {
77208       {
77209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77210       };
77211     } catch (Dali::DaliException e) {
77212       {
77213         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77214       };
77215     } catch (...) {
77216       {
77217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77218       };
77219     }
77220   }
77221
77222   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
77223   return jresult;
77224 }
77225
77226
77227 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_GetItemsRange(void * jarg1, void * jarg2) {
77228   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77229   Dali::Toolkit::ItemRange *arg2 = 0 ;
77230
77231   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77232   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
77233   if (!arg2) {
77234     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange & type is null", 0);
77235     return ;
77236   }
77237   {
77238     try {
77239       (arg1)->GetItemsRange(*arg2);
77240     } catch (std::out_of_range& e) {
77241       {
77242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77243       };
77244     } catch (std::exception& e) {
77245       {
77246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77247       };
77248     } catch (Dali::DaliException e) {
77249       {
77250         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77251       };
77252     } catch (...) {
77253       {
77254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77255       };
77256     }
77257   }
77258
77259 }
77260
77261
77262 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_LayoutActivatedSignal(void * jarg1) {
77263   void * jresult ;
77264   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77265   Dali::Toolkit::ItemView::LayoutActivatedSignalType *result = 0 ;
77266
77267   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77268   {
77269     try {
77270       result = (Dali::Toolkit::ItemView::LayoutActivatedSignalType *) &(arg1)->LayoutActivatedSignal();
77271     } catch (std::out_of_range& e) {
77272       {
77273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77274       };
77275     } catch (std::exception& e) {
77276       {
77277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77278       };
77279     } catch (Dali::DaliException e) {
77280       {
77281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77282       };
77283     } catch (...) {
77284       {
77285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77286       };
77287     }
77288   }
77289
77290   jresult = (void *)result;
77291   return jresult;
77292 }
77293
77294
77295 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MoveActorConstraint(void * jarg1, void * jarg2) {
77296   Dali::Vector3 *arg1 = 0 ;
77297   PropertyInputContainer *arg2 = 0 ;
77298
77299   arg1 = (Dali::Vector3 *)jarg1;
77300   if (!arg1) {
77301     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
77302     return ;
77303   }
77304   arg2 = (PropertyInputContainer *)jarg2;
77305   if (!arg2) {
77306     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
77307     return ;
77308   }
77309   {
77310     try {
77311       Dali::Toolkit::MoveActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
77312     } catch (std::out_of_range& e) {
77313       {
77314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77315       };
77316     } catch (std::exception& e) {
77317       {
77318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77319       };
77320     } catch (Dali::DaliException e) {
77321       {
77322         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77323       };
77324     } catch (...) {
77325       {
77326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77327       };
77328     }
77329   }
77330
77331 }
77332
77333
77334 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WrapActorConstraint(void * jarg1, void * jarg2) {
77335   Dali::Vector3 *arg1 = 0 ;
77336   PropertyInputContainer *arg2 = 0 ;
77337
77338   arg1 = (Dali::Vector3 *)jarg1;
77339   if (!arg1) {
77340     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
77341     return ;
77342   }
77343   arg2 = (PropertyInputContainer *)jarg2;
77344   if (!arg2) {
77345     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
77346     return ;
77347   }
77348   {
77349     try {
77350       Dali::Toolkit::WrapActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
77351     } catch (std::out_of_range& e) {
77352       {
77353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77354       };
77355     } catch (std::exception& e) {
77356       {
77357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77358       };
77359     } catch (Dali::DaliException e) {
77360       {
77361         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77362       };
77363     } catch (...) {
77364       {
77365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77366       };
77367     }
77368   }
77369
77370 }
77371
77372
77373 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewEffect() {
77374   void * jresult ;
77375   Dali::Toolkit::ScrollViewEffect *result = 0 ;
77376
77377   {
77378     try {
77379       result = (Dali::Toolkit::ScrollViewEffect *)new Dali::Toolkit::ScrollViewEffect();
77380     } catch (std::out_of_range& e) {
77381       {
77382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77383       };
77384     } catch (std::exception& e) {
77385       {
77386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77387       };
77388     } catch (Dali::DaliException e) {
77389       {
77390         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77391       };
77392     } catch (...) {
77393       {
77394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77395       };
77396     }
77397   }
77398
77399   jresult = (void *)result;
77400   return jresult;
77401 }
77402
77403
77404 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewEffect(void * jarg1) {
77405   Dali::Toolkit::ScrollViewEffect *arg1 = (Dali::Toolkit::ScrollViewEffect *) 0 ;
77406
77407   arg1 = (Dali::Toolkit::ScrollViewEffect *)jarg1;
77408   {
77409     try {
77410       delete arg1;
77411     } catch (std::out_of_range& e) {
77412       {
77413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77414       };
77415     } catch (std::exception& e) {
77416       {
77417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77418       };
77419     } catch (Dali::DaliException e) {
77420       {
77421         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77422       };
77423     } catch (...) {
77424       {
77425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77426       };
77427     }
77428   }
77429
77430 }
77431
77432
77433 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_New(void * jarg1, void * jarg2, int jarg3, void * jarg4, unsigned int jarg5) {
77434   void * jresult ;
77435   Dali::Path arg1 ;
77436   Dali::Vector3 *arg2 = 0 ;
77437   Dali::Property::Index arg3 ;
77438   Dali::Vector3 *arg4 = 0 ;
77439   unsigned int arg5 ;
77440   Dali::Path *argp1 ;
77441   Dali::Toolkit::ScrollViewPagePathEffect result;
77442
77443   argp1 = (Dali::Path *)jarg1;
77444   if (!argp1) {
77445     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
77446     return 0;
77447   }
77448   arg1 = *argp1;
77449   arg2 = (Dali::Vector3 *)jarg2;
77450   if (!arg2) {
77451     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
77452     return 0;
77453   }
77454   arg3 = (Dali::Property::Index)jarg3;
77455   arg4 = (Dali::Vector3 *)jarg4;
77456   if (!arg4) {
77457     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
77458     return 0;
77459   }
77460   arg5 = (unsigned int)jarg5;
77461   {
77462     try {
77463       result = Dali::Toolkit::ScrollViewPagePathEffect::New(arg1,(Dali::Vector3 const &)*arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
77464     } catch (std::out_of_range& e) {
77465       {
77466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77467       };
77468     } catch (std::exception& e) {
77469       {
77470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77471       };
77472     } catch (Dali::DaliException e) {
77473       {
77474         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77475       };
77476     } catch (...) {
77477       {
77478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77479       };
77480     }
77481   }
77482
77483   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
77484   return jresult;
77485 }
77486
77487
77488 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewPagePathEffect() {
77489   void * jresult ;
77490   Dali::Toolkit::ScrollViewPagePathEffect *result = 0 ;
77491
77492   {
77493     try {
77494       result = (Dali::Toolkit::ScrollViewPagePathEffect *)new Dali::Toolkit::ScrollViewPagePathEffect();
77495     } catch (std::out_of_range& e) {
77496       {
77497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77498       };
77499     } catch (std::exception& e) {
77500       {
77501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77502       };
77503     } catch (Dali::DaliException e) {
77504       {
77505         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77506       };
77507     } catch (...) {
77508       {
77509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77510       };
77511     }
77512   }
77513
77514   jresult = (void *)result;
77515   return jresult;
77516 }
77517
77518
77519 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_DownCast(void * jarg1) {
77520   void * jresult ;
77521   Dali::BaseHandle arg1 ;
77522   Dali::BaseHandle *argp1 ;
77523   Dali::Toolkit::ScrollViewPagePathEffect result;
77524
77525   argp1 = (Dali::BaseHandle *)jarg1;
77526   if (!argp1) {
77527     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
77528     return 0;
77529   }
77530   arg1 = *argp1;
77531   {
77532     try {
77533       result = Dali::Toolkit::ScrollViewPagePathEffect::DownCast(arg1);
77534     } catch (std::out_of_range& e) {
77535       {
77536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77537       };
77538     } catch (std::exception& e) {
77539       {
77540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77541       };
77542     } catch (Dali::DaliException e) {
77543       {
77544         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77545       };
77546     } catch (...) {
77547       {
77548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77549       };
77550     }
77551   }
77552
77553   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
77554   return jresult;
77555 }
77556
77557
77558 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_ApplyToPage(void * jarg1, void * jarg2, unsigned int jarg3) {
77559   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
77560   Dali::Actor arg2 ;
77561   unsigned int arg3 ;
77562   Dali::Actor *argp2 ;
77563
77564   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
77565   argp2 = (Dali::Actor *)jarg2;
77566   if (!argp2) {
77567     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
77568     return ;
77569   }
77570   arg2 = *argp2;
77571   arg3 = (unsigned int)jarg3;
77572   {
77573     try {
77574       (arg1)->ApplyToPage(arg2,arg3);
77575     } catch (std::out_of_range& e) {
77576       {
77577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77578       };
77579     } catch (std::exception& e) {
77580       {
77581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77582       };
77583     } catch (Dali::DaliException e) {
77584       {
77585         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77586       };
77587     } catch (...) {
77588       {
77589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77590       };
77591     }
77592   }
77593
77594 }
77595
77596
77597 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewPagePathEffect(void * jarg1) {
77598   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
77599
77600   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
77601   {
77602     try {
77603       delete arg1;
77604     } catch (std::out_of_range& e) {
77605       {
77606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77607       };
77608     } catch (std::exception& e) {
77609       {
77610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77611       };
77612     } catch (Dali::DaliException e) {
77613       {
77614         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77615       };
77616     } catch (...) {
77617       {
77618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77619       };
77620     }
77621   }
77622
77623 }
77624
77625
77626 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_x_set(void * jarg1, int jarg2) {
77627   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
77628   Dali::Toolkit::ClampState arg2 ;
77629
77630   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
77631   arg2 = (Dali::Toolkit::ClampState)jarg2;
77632   if (arg1) (arg1)->x = arg2;
77633 }
77634
77635
77636 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_x_get(void * jarg1) {
77637   int jresult ;
77638   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
77639   Dali::Toolkit::ClampState result;
77640
77641   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
77642   result = (Dali::Toolkit::ClampState) ((arg1)->x);
77643   jresult = (int)result;
77644   return jresult;
77645 }
77646
77647
77648 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_y_set(void * jarg1, int jarg2) {
77649   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
77650   Dali::Toolkit::ClampState arg2 ;
77651
77652   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
77653   arg2 = (Dali::Toolkit::ClampState)jarg2;
77654   if (arg1) (arg1)->y = arg2;
77655 }
77656
77657
77658 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_y_get(void * jarg1) {
77659   int jresult ;
77660   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
77661   Dali::Toolkit::ClampState result;
77662
77663   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
77664   result = (Dali::Toolkit::ClampState) ((arg1)->y);
77665   jresult = (int)result;
77666   return jresult;
77667 }
77668
77669
77670 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ClampState2D() {
77671   void * jresult ;
77672   Dali::Toolkit::ClampState2D *result = 0 ;
77673
77674   {
77675     try {
77676       result = (Dali::Toolkit::ClampState2D *)new Dali::Toolkit::ClampState2D();
77677     } catch (std::out_of_range& e) {
77678       {
77679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77680       };
77681     } catch (std::exception& e) {
77682       {
77683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77684       };
77685     } catch (Dali::DaliException e) {
77686       {
77687         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77688       };
77689     } catch (...) {
77690       {
77691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77692       };
77693     }
77694   }
77695
77696   jresult = (void *)result;
77697   return jresult;
77698 }
77699
77700
77701 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ClampState2D(void * jarg1) {
77702   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
77703
77704   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
77705   {
77706     try {
77707       delete arg1;
77708     } catch (std::out_of_range& e) {
77709       {
77710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77711       };
77712     } catch (std::exception& e) {
77713       {
77714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77715       };
77716     } catch (Dali::DaliException e) {
77717       {
77718         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77719       };
77720     } catch (...) {
77721       {
77722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77723       };
77724     }
77725   }
77726
77727 }
77728
77729
77730 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_0(float jarg1, float jarg2, unsigned int jarg3) {
77731   void * jresult ;
77732   float arg1 ;
77733   float arg2 ;
77734   bool arg3 ;
77735   Dali::Toolkit::RulerDomain *result = 0 ;
77736
77737   arg1 = (float)jarg1;
77738   arg2 = (float)jarg2;
77739   arg3 = jarg3 ? true : false;
77740   {
77741     try {
77742       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2,arg3);
77743     } catch (std::out_of_range& e) {
77744       {
77745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77746       };
77747     } catch (std::exception& e) {
77748       {
77749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77750       };
77751     } catch (Dali::DaliException e) {
77752       {
77753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77754       };
77755     } catch (...) {
77756       {
77757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77758       };
77759     }
77760   }
77761
77762   jresult = (void *)result;
77763   return jresult;
77764 }
77765
77766
77767 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_1(float jarg1, float jarg2) {
77768   void * jresult ;
77769   float arg1 ;
77770   float arg2 ;
77771   Dali::Toolkit::RulerDomain *result = 0 ;
77772
77773   arg1 = (float)jarg1;
77774   arg2 = (float)jarg2;
77775   {
77776     try {
77777       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2);
77778     } catch (std::out_of_range& e) {
77779       {
77780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77781       };
77782     } catch (std::exception& e) {
77783       {
77784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77785       };
77786     } catch (Dali::DaliException e) {
77787       {
77788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77789       };
77790     } catch (...) {
77791       {
77792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77793       };
77794     }
77795   }
77796
77797   jresult = (void *)result;
77798   return jresult;
77799 }
77800
77801
77802 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_min_set(void * jarg1, float jarg2) {
77803   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77804   float arg2 ;
77805
77806   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77807   arg2 = (float)jarg2;
77808   if (arg1) (arg1)->min = arg2;
77809 }
77810
77811
77812 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_min_get(void * jarg1) {
77813   float jresult ;
77814   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77815   float result;
77816
77817   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77818   result = (float) ((arg1)->min);
77819   jresult = result;
77820   return jresult;
77821 }
77822
77823
77824 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_max_set(void * jarg1, float jarg2) {
77825   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77826   float arg2 ;
77827
77828   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77829   arg2 = (float)jarg2;
77830   if (arg1) (arg1)->max = arg2;
77831 }
77832
77833
77834 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_max_get(void * jarg1) {
77835   float jresult ;
77836   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77837   float result;
77838
77839   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77840   result = (float) ((arg1)->max);
77841   jresult = result;
77842   return jresult;
77843 }
77844
77845
77846 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_set(void * jarg1, unsigned int jarg2) {
77847   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77848   bool arg2 ;
77849
77850   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77851   arg2 = jarg2 ? true : false;
77852   if (arg1) (arg1)->enabled = arg2;
77853 }
77854
77855
77856 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_get(void * jarg1) {
77857   unsigned int jresult ;
77858   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77859   bool result;
77860
77861   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77862   result = (bool) ((arg1)->enabled);
77863   jresult = result;
77864   return jresult;
77865 }
77866
77867
77868 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
77869   float jresult ;
77870   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77871   float arg2 ;
77872   float arg3 ;
77873   float arg4 ;
77874   float result;
77875
77876   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77877   arg2 = (float)jarg2;
77878   arg3 = (float)jarg3;
77879   arg4 = (float)jarg4;
77880   {
77881     try {
77882       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4);
77883     } catch (std::out_of_range& e) {
77884       {
77885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77886       };
77887     } catch (std::exception& e) {
77888       {
77889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77890       };
77891     } catch (Dali::DaliException e) {
77892       {
77893         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77894       };
77895     } catch (...) {
77896       {
77897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77898       };
77899     }
77900   }
77901
77902   jresult = result;
77903   return jresult;
77904 }
77905
77906
77907 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
77908   float jresult ;
77909   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77910   float arg2 ;
77911   float arg3 ;
77912   float result;
77913
77914   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77915   arg2 = (float)jarg2;
77916   arg3 = (float)jarg3;
77917   {
77918     try {
77919       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3);
77920     } catch (std::out_of_range& e) {
77921       {
77922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77923       };
77924     } catch (std::exception& e) {
77925       {
77926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77927       };
77928     } catch (Dali::DaliException e) {
77929       {
77930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77931       };
77932     } catch (...) {
77933       {
77934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77935       };
77936     }
77937   }
77938
77939   jresult = result;
77940   return jresult;
77941 }
77942
77943
77944 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_2(void * jarg1, float jarg2) {
77945   float jresult ;
77946   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77947   float arg2 ;
77948   float result;
77949
77950   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77951   arg2 = (float)jarg2;
77952   {
77953     try {
77954       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2);
77955     } catch (std::out_of_range& e) {
77956       {
77957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77958       };
77959     } catch (std::exception& e) {
77960       {
77961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77962       };
77963     } catch (Dali::DaliException e) {
77964       {
77965         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77966       };
77967     } catch (...) {
77968       {
77969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77970       };
77971     }
77972   }
77973
77974   jresult = result;
77975   return jresult;
77976 }
77977
77978
77979 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
77980   float jresult ;
77981   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77982   float arg2 ;
77983   float arg3 ;
77984   float arg4 ;
77985   Dali::Toolkit::ClampState *arg5 = 0 ;
77986   float result;
77987
77988   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77989   arg2 = (float)jarg2;
77990   arg3 = (float)jarg3;
77991   arg4 = (float)jarg4;
77992   arg5 = (Dali::Toolkit::ClampState *)jarg5;
77993   if (!arg5) {
77994     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
77995     return 0;
77996   }
77997   {
77998     try {
77999       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
78000     } catch (std::out_of_range& e) {
78001       {
78002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78003       };
78004     } catch (std::exception& e) {
78005       {
78006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78007       };
78008     } catch (Dali::DaliException e) {
78009       {
78010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78011       };
78012     } catch (...) {
78013       {
78014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78015       };
78016     }
78017   }
78018
78019   jresult = result;
78020   return jresult;
78021 }
78022
78023
78024 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_GetSize(void * jarg1) {
78025   float jresult ;
78026   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78027   float result;
78028
78029   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78030   {
78031     try {
78032       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->GetSize();
78033     } catch (std::out_of_range& e) {
78034       {
78035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78036       };
78037     } catch (std::exception& e) {
78038       {
78039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78040       };
78041     } catch (Dali::DaliException e) {
78042       {
78043         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78044       };
78045     } catch (...) {
78046       {
78047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78048       };
78049     }
78050   }
78051
78052   jresult = result;
78053   return jresult;
78054 }
78055
78056
78057 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerDomain(void * jarg1) {
78058   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78059
78060   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78061   {
78062     try {
78063       delete arg1;
78064     } catch (std::out_of_range& e) {
78065       {
78066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78067       };
78068     } catch (std::exception& e) {
78069       {
78070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78071       };
78072     } catch (Dali::DaliException e) {
78073       {
78074         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78075       };
78076     } catch (...) {
78077       {
78078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78079       };
78080     }
78081   }
78082
78083 }
78084
78085
78086 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
78087   float jresult ;
78088   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78089   float arg2 ;
78090   float arg3 ;
78091   float result;
78092
78093   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78094   arg2 = (float)jarg2;
78095   arg3 = (float)jarg3;
78096   {
78097     try {
78098       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2,arg3);
78099     } catch (std::out_of_range& e) {
78100       {
78101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78102       };
78103     } catch (std::exception& e) {
78104       {
78105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78106       };
78107     } catch (Dali::DaliException e) {
78108       {
78109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78110       };
78111     } catch (...) {
78112       {
78113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78114       };
78115     }
78116   }
78117
78118   jresult = result;
78119   return jresult;
78120 }
78121
78122
78123 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_1(void * jarg1, float jarg2) {
78124   float jresult ;
78125   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78126   float arg2 ;
78127   float result;
78128
78129   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78130   arg2 = (float)jarg2;
78131   {
78132     try {
78133       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2);
78134     } catch (std::out_of_range& e) {
78135       {
78136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78137       };
78138     } catch (std::exception& e) {
78139       {
78140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78141       };
78142     } catch (Dali::DaliException e) {
78143       {
78144         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78145       };
78146     } catch (...) {
78147       {
78148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78149       };
78150     }
78151   }
78152
78153   jresult = result;
78154   return jresult;
78155 }
78156
78157
78158 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
78159   float jresult ;
78160   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78161   unsigned int arg2 ;
78162   unsigned int *arg3 = 0 ;
78163   bool arg4 ;
78164   float result;
78165
78166   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78167   arg2 = (unsigned int)jarg2;
78168   arg3 = (unsigned int *)jarg3;
78169   arg4 = jarg4 ? true : false;
78170   {
78171     try {
78172       result = (float)((Dali::Toolkit::Ruler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
78173     } catch (std::out_of_range& e) {
78174       {
78175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78176       };
78177     } catch (std::exception& e) {
78178       {
78179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78180       };
78181     } catch (Dali::DaliException e) {
78182       {
78183         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78184       };
78185     } catch (...) {
78186       {
78187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78188       };
78189     }
78190   }
78191
78192   jresult = result;
78193   return jresult;
78194 }
78195
78196
78197 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
78198   unsigned int jresult ;
78199   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78200   float arg2 ;
78201   bool arg3 ;
78202   unsigned int result;
78203
78204   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78205   arg2 = (float)jarg2;
78206   arg3 = jarg3 ? true : false;
78207   {
78208     try {
78209       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetPageFromPosition(arg2,arg3);
78210     } catch (std::out_of_range& e) {
78211       {
78212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78213       };
78214     } catch (std::exception& e) {
78215       {
78216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78217       };
78218     } catch (Dali::DaliException e) {
78219       {
78220         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78221       };
78222     } catch (...) {
78223       {
78224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78225       };
78226     }
78227   }
78228
78229   jresult = result;
78230   return jresult;
78231 }
78232
78233
78234 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetTotalPages(void * jarg1) {
78235   unsigned int jresult ;
78236   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78237   unsigned int result;
78238
78239   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78240   {
78241     try {
78242       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetTotalPages();
78243     } catch (std::out_of_range& e) {
78244       {
78245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78246       };
78247     } catch (std::exception& e) {
78248       {
78249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78250       };
78251     } catch (Dali::DaliException e) {
78252       {
78253         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78254       };
78255     } catch (...) {
78256       {
78257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78258       };
78259     }
78260   }
78261
78262   jresult = result;
78263   return jresult;
78264 }
78265
78266
78267 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Ruler_GetType(void * jarg1) {
78268   int jresult ;
78269   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78270   Dali::Toolkit::Ruler::RulerType result;
78271
78272   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78273   {
78274     try {
78275       result = (Dali::Toolkit::Ruler::RulerType)((Dali::Toolkit::Ruler const *)arg1)->GetType();
78276     } catch (std::out_of_range& e) {
78277       {
78278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78279       };
78280     } catch (std::exception& e) {
78281       {
78282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78283       };
78284     } catch (Dali::DaliException e) {
78285       {
78286         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78287       };
78288     } catch (...) {
78289       {
78290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78291       };
78292     }
78293   }
78294
78295   jresult = (int)result;
78296   return jresult;
78297 }
78298
78299
78300 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_IsEnabled(void * jarg1) {
78301   unsigned int jresult ;
78302   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78303   bool result;
78304
78305   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78306   {
78307     try {
78308       result = (bool)((Dali::Toolkit::Ruler const *)arg1)->IsEnabled();
78309     } catch (std::out_of_range& e) {
78310       {
78311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78312       };
78313     } catch (std::exception& e) {
78314       {
78315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78316       };
78317     } catch (Dali::DaliException e) {
78318       {
78319         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78320       };
78321     } catch (...) {
78322       {
78323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78324       };
78325     }
78326   }
78327
78328   jresult = result;
78329   return jresult;
78330 }
78331
78332
78333 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Enable(void * jarg1) {
78334   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78335
78336   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78337   {
78338     try {
78339       (arg1)->Enable();
78340     } catch (std::out_of_range& e) {
78341       {
78342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78343       };
78344     } catch (std::exception& e) {
78345       {
78346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78347       };
78348     } catch (Dali::DaliException e) {
78349       {
78350         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78351       };
78352     } catch (...) {
78353       {
78354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78355       };
78356     }
78357   }
78358
78359 }
78360
78361
78362 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Disable(void * jarg1) {
78363   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78364
78365   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78366   {
78367     try {
78368       (arg1)->Disable();
78369     } catch (std::out_of_range& e) {
78370       {
78371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78372       };
78373     } catch (std::exception& e) {
78374       {
78375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78376       };
78377     } catch (Dali::DaliException e) {
78378       {
78379         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78380       };
78381     } catch (...) {
78382       {
78383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78384       };
78385     }
78386   }
78387
78388 }
78389
78390
78391 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_SetDomain(void * jarg1, void * jarg2) {
78392   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78393   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
78394   Dali::Toolkit::RulerDomain *argp2 ;
78395
78396   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78397   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
78398   if (!argp2) {
78399     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
78400     return ;
78401   }
78402   arg2 = *argp2;
78403   {
78404     try {
78405       (arg1)->SetDomain(arg2);
78406     } catch (std::out_of_range& e) {
78407       {
78408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78409       };
78410     } catch (std::exception& e) {
78411       {
78412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78413       };
78414     } catch (Dali::DaliException e) {
78415       {
78416         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78417       };
78418     } catch (...) {
78419       {
78420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78421       };
78422     }
78423   }
78424
78425 }
78426
78427
78428 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Ruler_GetDomain(void * jarg1) {
78429   void * jresult ;
78430   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78431   Dali::Toolkit::RulerDomain *result = 0 ;
78432
78433   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78434   {
78435     try {
78436       result = (Dali::Toolkit::RulerDomain *) &((Dali::Toolkit::Ruler const *)arg1)->GetDomain();
78437     } catch (std::out_of_range& e) {
78438       {
78439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78440       };
78441     } catch (std::exception& e) {
78442       {
78443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78444       };
78445     } catch (Dali::DaliException e) {
78446       {
78447         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78448       };
78449     } catch (...) {
78450       {
78451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78452       };
78453     }
78454   }
78455
78456   jresult = (void *)result;
78457   return jresult;
78458 }
78459
78460
78461 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_DisableDomain(void * jarg1) {
78462   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78463
78464   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78465   {
78466     try {
78467       (arg1)->DisableDomain();
78468     } catch (std::out_of_range& e) {
78469       {
78470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78471       };
78472     } catch (std::exception& e) {
78473       {
78474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78475       };
78476     } catch (Dali::DaliException e) {
78477       {
78478         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78479       };
78480     } catch (...) {
78481       {
78482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78483       };
78484     }
78485   }
78486
78487 }
78488
78489
78490 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
78491   float jresult ;
78492   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78493   float arg2 ;
78494   float arg3 ;
78495   float arg4 ;
78496   float result;
78497
78498   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78499   arg2 = (float)jarg2;
78500   arg3 = (float)jarg3;
78501   arg4 = (float)jarg4;
78502   {
78503     try {
78504       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4);
78505     } catch (std::out_of_range& e) {
78506       {
78507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78508       };
78509     } catch (std::exception& e) {
78510       {
78511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78512       };
78513     } catch (Dali::DaliException e) {
78514       {
78515         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78516       };
78517     } catch (...) {
78518       {
78519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78520       };
78521     }
78522   }
78523
78524   jresult = result;
78525   return jresult;
78526 }
78527
78528
78529 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
78530   float jresult ;
78531   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78532   float arg2 ;
78533   float arg3 ;
78534   float result;
78535
78536   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78537   arg2 = (float)jarg2;
78538   arg3 = (float)jarg3;
78539   {
78540     try {
78541       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3);
78542     } catch (std::out_of_range& e) {
78543       {
78544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78545       };
78546     } catch (std::exception& e) {
78547       {
78548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78549       };
78550     } catch (Dali::DaliException e) {
78551       {
78552         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78553       };
78554     } catch (...) {
78555       {
78556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78557       };
78558     }
78559   }
78560
78561   jresult = result;
78562   return jresult;
78563 }
78564
78565
78566 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_2(void * jarg1, float jarg2) {
78567   float jresult ;
78568   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78569   float arg2 ;
78570   float result;
78571
78572   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78573   arg2 = (float)jarg2;
78574   {
78575     try {
78576       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2);
78577     } catch (std::out_of_range& e) {
78578       {
78579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78580       };
78581     } catch (std::exception& e) {
78582       {
78583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78584       };
78585     } catch (Dali::DaliException e) {
78586       {
78587         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78588       };
78589     } catch (...) {
78590       {
78591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78592       };
78593     }
78594   }
78595
78596   jresult = result;
78597   return jresult;
78598 }
78599
78600
78601 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
78602   float jresult ;
78603   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78604   float arg2 ;
78605   float arg3 ;
78606   float arg4 ;
78607   Dali::Toolkit::ClampState *arg5 = 0 ;
78608   float result;
78609
78610   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78611   arg2 = (float)jarg2;
78612   arg3 = (float)jarg3;
78613   arg4 = (float)jarg4;
78614   arg5 = (Dali::Toolkit::ClampState *)jarg5;
78615   if (!arg5) {
78616     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
78617     return 0;
78618   }
78619   {
78620     try {
78621       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
78622     } catch (std::out_of_range& e) {
78623       {
78624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78625       };
78626     } catch (std::exception& e) {
78627       {
78628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78629       };
78630     } catch (Dali::DaliException e) {
78631       {
78632         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78633       };
78634     } catch (...) {
78635       {
78636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78637       };
78638     }
78639   }
78640
78641   jresult = result;
78642   return jresult;
78643 }
78644
78645
78646 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
78647   float jresult ;
78648   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78649   float arg2 ;
78650   float arg3 ;
78651   float arg4 ;
78652   float arg5 ;
78653   float result;
78654
78655   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78656   arg2 = (float)jarg2;
78657   arg3 = (float)jarg3;
78658   arg4 = (float)jarg4;
78659   arg5 = (float)jarg5;
78660   {
78661     try {
78662       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
78663     } catch (std::out_of_range& e) {
78664       {
78665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78666       };
78667     } catch (std::exception& e) {
78668       {
78669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78670       };
78671     } catch (Dali::DaliException e) {
78672       {
78673         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78674       };
78675     } catch (...) {
78676       {
78677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78678       };
78679     }
78680   }
78681
78682   jresult = result;
78683   return jresult;
78684 }
78685
78686
78687 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
78688   float jresult ;
78689   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78690   float arg2 ;
78691   float arg3 ;
78692   float arg4 ;
78693   float result;
78694
78695   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78696   arg2 = (float)jarg2;
78697   arg3 = (float)jarg3;
78698   arg4 = (float)jarg4;
78699   {
78700     try {
78701       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4);
78702     } catch (std::out_of_range& e) {
78703       {
78704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78705       };
78706     } catch (std::exception& e) {
78707       {
78708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78709       };
78710     } catch (Dali::DaliException e) {
78711       {
78712         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78713       };
78714     } catch (...) {
78715       {
78716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78717       };
78718     }
78719   }
78720
78721   jresult = result;
78722   return jresult;
78723 }
78724
78725
78726 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
78727   float jresult ;
78728   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78729   float arg2 ;
78730   float arg3 ;
78731   float result;
78732
78733   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78734   arg2 = (float)jarg2;
78735   arg3 = (float)jarg3;
78736   {
78737     try {
78738       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3);
78739     } catch (std::out_of_range& e) {
78740       {
78741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78742       };
78743     } catch (std::exception& e) {
78744       {
78745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78746       };
78747     } catch (Dali::DaliException e) {
78748       {
78749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78750       };
78751     } catch (...) {
78752       {
78753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78754       };
78755     }
78756   }
78757
78758   jresult = result;
78759   return jresult;
78760 }
78761
78762
78763 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
78764   float jresult ;
78765   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78766   float arg2 ;
78767   float result;
78768
78769   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78770   arg2 = (float)jarg2;
78771   {
78772     try {
78773       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2);
78774     } catch (std::out_of_range& e) {
78775       {
78776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78777       };
78778     } catch (std::exception& e) {
78779       {
78780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78781       };
78782     } catch (Dali::DaliException e) {
78783       {
78784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78785       };
78786     } catch (...) {
78787       {
78788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78789       };
78790     }
78791   }
78792
78793   jresult = result;
78794   return jresult;
78795 }
78796
78797
78798 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
78799   float jresult ;
78800   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78801   float arg2 ;
78802   float arg3 ;
78803   float arg4 ;
78804   float arg5 ;
78805   Dali::Toolkit::ClampState *arg6 = 0 ;
78806   float result;
78807
78808   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78809   arg2 = (float)jarg2;
78810   arg3 = (float)jarg3;
78811   arg4 = (float)jarg4;
78812   arg5 = (float)jarg5;
78813   arg6 = (Dali::Toolkit::ClampState *)jarg6;
78814   if (!arg6) {
78815     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
78816     return 0;
78817   }
78818   {
78819     try {
78820       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
78821     } catch (std::out_of_range& e) {
78822       {
78823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78824       };
78825     } catch (std::exception& e) {
78826       {
78827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78828       };
78829     } catch (Dali::DaliException e) {
78830       {
78831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78832       };
78833     } catch (...) {
78834       {
78835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78836       };
78837     }
78838   }
78839
78840   jresult = result;
78841   return jresult;
78842 }
78843
78844
78845 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DefaultRuler() {
78846   void * jresult ;
78847   Dali::Toolkit::DefaultRuler *result = 0 ;
78848
78849   {
78850     try {
78851       result = (Dali::Toolkit::DefaultRuler *)new Dali::Toolkit::DefaultRuler();
78852     } catch (std::out_of_range& e) {
78853       {
78854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78855       };
78856     } catch (std::exception& e) {
78857       {
78858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78859       };
78860     } catch (Dali::DaliException e) {
78861       {
78862         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78863       };
78864     } catch (...) {
78865       {
78866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78867       };
78868     }
78869   }
78870
78871   jresult = (void *)result;
78872   return jresult;
78873 }
78874
78875
78876 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_Snap(void * jarg1, float jarg2, float jarg3) {
78877   float jresult ;
78878   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
78879   float arg2 ;
78880   float arg3 ;
78881   float result;
78882
78883   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
78884   arg2 = (float)jarg2;
78885   arg3 = (float)jarg3;
78886   {
78887     try {
78888       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->Snap(arg2,arg3);
78889     } catch (std::out_of_range& e) {
78890       {
78891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78892       };
78893     } catch (std::exception& e) {
78894       {
78895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78896       };
78897     } catch (Dali::DaliException e) {
78898       {
78899         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78900       };
78901     } catch (...) {
78902       {
78903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78904       };
78905     }
78906   }
78907
78908   jresult = result;
78909   return jresult;
78910 }
78911
78912
78913 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
78914   float jresult ;
78915   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
78916   unsigned int arg2 ;
78917   unsigned int *arg3 = 0 ;
78918   bool arg4 ;
78919   float result;
78920
78921   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
78922   arg2 = (unsigned int)jarg2;
78923   arg3 = (unsigned int *)jarg3;
78924   arg4 = jarg4 ? true : false;
78925   {
78926     try {
78927       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
78928     } catch (std::out_of_range& e) {
78929       {
78930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78931       };
78932     } catch (std::exception& e) {
78933       {
78934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78935       };
78936     } catch (Dali::DaliException e) {
78937       {
78938         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78939       };
78940     } catch (...) {
78941       {
78942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78943       };
78944     }
78945   }
78946
78947   jresult = result;
78948   return jresult;
78949 }
78950
78951
78952 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
78953   unsigned int jresult ;
78954   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
78955   float arg2 ;
78956   bool arg3 ;
78957   unsigned int result;
78958
78959   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
78960   arg2 = (float)jarg2;
78961   arg3 = jarg3 ? true : false;
78962   {
78963     try {
78964       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
78965     } catch (std::out_of_range& e) {
78966       {
78967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78968       };
78969     } catch (std::exception& e) {
78970       {
78971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78972       };
78973     } catch (Dali::DaliException e) {
78974       {
78975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78976       };
78977     } catch (...) {
78978       {
78979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78980       };
78981     }
78982   }
78983
78984   jresult = result;
78985   return jresult;
78986 }
78987
78988
78989 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetTotalPages(void * jarg1) {
78990   unsigned int jresult ;
78991   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
78992   unsigned int result;
78993
78994   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
78995   {
78996     try {
78997       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetTotalPages();
78998     } catch (std::out_of_range& e) {
78999       {
79000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79001       };
79002     } catch (std::exception& e) {
79003       {
79004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79005       };
79006     } catch (Dali::DaliException e) {
79007       {
79008         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79009       };
79010     } catch (...) {
79011       {
79012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79013       };
79014     }
79015   }
79016
79017   jresult = result;
79018   return jresult;
79019 }
79020
79021
79022 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DefaultRuler(void * jarg1) {
79023   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
79024
79025   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
79026   {
79027     try {
79028       delete arg1;
79029     } catch (std::out_of_range& e) {
79030       {
79031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79032       };
79033     } catch (std::exception& e) {
79034       {
79035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79036       };
79037     } catch (Dali::DaliException e) {
79038       {
79039         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79040       };
79041     } catch (...) {
79042       {
79043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79044       };
79045     }
79046   }
79047
79048 }
79049
79050
79051 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_0(float jarg1) {
79052   void * jresult ;
79053   float arg1 ;
79054   Dali::Toolkit::FixedRuler *result = 0 ;
79055
79056   arg1 = (float)jarg1;
79057   {
79058     try {
79059       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler(arg1);
79060     } catch (std::out_of_range& e) {
79061       {
79062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79063       };
79064     } catch (std::exception& e) {
79065       {
79066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79067       };
79068     } catch (Dali::DaliException e) {
79069       {
79070         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79071       };
79072     } catch (...) {
79073       {
79074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79075       };
79076     }
79077   }
79078
79079   jresult = (void *)result;
79080   return jresult;
79081 }
79082
79083
79084 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_1() {
79085   void * jresult ;
79086   Dali::Toolkit::FixedRuler *result = 0 ;
79087
79088   {
79089     try {
79090       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler();
79091     } catch (std::out_of_range& e) {
79092       {
79093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79094       };
79095     } catch (std::exception& e) {
79096       {
79097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79098       };
79099     } catch (Dali::DaliException e) {
79100       {
79101         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79102       };
79103     } catch (...) {
79104       {
79105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79106       };
79107     }
79108   }
79109
79110   jresult = (void *)result;
79111   return jresult;
79112 }
79113
79114
79115 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_Snap(void * jarg1, float jarg2, float jarg3) {
79116   float jresult ;
79117   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
79118   float arg2 ;
79119   float arg3 ;
79120   float result;
79121
79122   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
79123   arg2 = (float)jarg2;
79124   arg3 = (float)jarg3;
79125   {
79126     try {
79127       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->Snap(arg2,arg3);
79128     } catch (std::out_of_range& e) {
79129       {
79130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79131       };
79132     } catch (std::exception& e) {
79133       {
79134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79135       };
79136     } catch (Dali::DaliException e) {
79137       {
79138         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79139       };
79140     } catch (...) {
79141       {
79142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79143       };
79144     }
79145   }
79146
79147   jresult = result;
79148   return jresult;
79149 }
79150
79151
79152 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
79153   float jresult ;
79154   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
79155   unsigned int arg2 ;
79156   unsigned int *arg3 = 0 ;
79157   bool arg4 ;
79158   float result;
79159
79160   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
79161   arg2 = (unsigned int)jarg2;
79162   arg3 = (unsigned int *)jarg3;
79163   arg4 = jarg4 ? true : false;
79164   {
79165     try {
79166       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
79167     } catch (std::out_of_range& e) {
79168       {
79169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79170       };
79171     } catch (std::exception& e) {
79172       {
79173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79174       };
79175     } catch (Dali::DaliException e) {
79176       {
79177         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79178       };
79179     } catch (...) {
79180       {
79181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79182       };
79183     }
79184   }
79185
79186   jresult = result;
79187   return jresult;
79188 }
79189
79190
79191 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
79192   unsigned int jresult ;
79193   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
79194   float arg2 ;
79195   bool arg3 ;
79196   unsigned int result;
79197
79198   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
79199   arg2 = (float)jarg2;
79200   arg3 = jarg3 ? true : false;
79201   {
79202     try {
79203       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
79204     } catch (std::out_of_range& e) {
79205       {
79206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79207       };
79208     } catch (std::exception& e) {
79209       {
79210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79211       };
79212     } catch (Dali::DaliException e) {
79213       {
79214         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79215       };
79216     } catch (...) {
79217       {
79218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79219       };
79220     }
79221   }
79222
79223   jresult = result;
79224   return jresult;
79225 }
79226
79227
79228 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetTotalPages(void * jarg1) {
79229   unsigned int jresult ;
79230   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
79231   unsigned int result;
79232
79233   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
79234   {
79235     try {
79236       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetTotalPages();
79237     } catch (std::out_of_range& e) {
79238       {
79239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79240       };
79241     } catch (std::exception& e) {
79242       {
79243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79244       };
79245     } catch (Dali::DaliException e) {
79246       {
79247         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79248       };
79249     } catch (...) {
79250       {
79251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79252       };
79253     }
79254   }
79255
79256   jresult = result;
79257   return jresult;
79258 }
79259
79260
79261 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FixedRuler(void * jarg1) {
79262   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
79263
79264   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
79265   {
79266     try {
79267       delete arg1;
79268     } catch (std::out_of_range& e) {
79269       {
79270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79271       };
79272     } catch (std::exception& e) {
79273       {
79274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79275       };
79276     } catch (Dali::DaliException e) {
79277       {
79278         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79279       };
79280     } catch (...) {
79281       {
79282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79283       };
79284     }
79285   }
79286
79287 }
79288
79289
79290 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_set(void * jarg1, void * jarg2) {
79291   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79292   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
79293
79294   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79295   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
79296   if (arg1) (arg1)->scale = *arg2;
79297 }
79298
79299
79300 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_get(void * jarg1) {
79301   void * jresult ;
79302   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79303   Dali::Toolkit::ClampState2D *result = 0 ;
79304
79305   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79306   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->scale);
79307   jresult = (void *)result;
79308   return jresult;
79309 }
79310
79311
79312 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_set(void * jarg1, void * jarg2) {
79313   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79314   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
79315
79316   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79317   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
79318   if (arg1) (arg1)->position = *arg2;
79319 }
79320
79321
79322 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_get(void * jarg1) {
79323   void * jresult ;
79324   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79325   Dali::Toolkit::ClampState2D *result = 0 ;
79326
79327   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79328   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->position);
79329   jresult = (void *)result;
79330   return jresult;
79331 }
79332
79333
79334 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_set(void * jarg1, int jarg2) {
79335   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79336   Dali::Toolkit::ClampState arg2 ;
79337
79338   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79339   arg2 = (Dali::Toolkit::ClampState)jarg2;
79340   if (arg1) (arg1)->rotation = arg2;
79341 }
79342
79343
79344 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_get(void * jarg1) {
79345   int jresult ;
79346   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79347   Dali::Toolkit::ClampState result;
79348
79349   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79350   result = (Dali::Toolkit::ClampState) ((arg1)->rotation);
79351   jresult = (int)result;
79352   return jresult;
79353 }
79354
79355
79356 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_ClampEvent() {
79357   void * jresult ;
79358   Dali::Toolkit::ScrollView::ClampEvent *result = 0 ;
79359
79360   {
79361     try {
79362       result = (Dali::Toolkit::ScrollView::ClampEvent *)new Dali::Toolkit::ScrollView::ClampEvent();
79363     } catch (std::out_of_range& e) {
79364       {
79365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79366       };
79367     } catch (std::exception& e) {
79368       {
79369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79370       };
79371     } catch (Dali::DaliException e) {
79372       {
79373         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79374       };
79375     } catch (...) {
79376       {
79377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79378       };
79379     }
79380   }
79381
79382   jresult = (void *)result;
79383   return jresult;
79384 }
79385
79386
79387 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_ClampEvent(void * jarg1) {
79388   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79389
79390   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79391   {
79392     try {
79393       delete arg1;
79394     } catch (std::out_of_range& e) {
79395       {
79396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79397       };
79398     } catch (std::exception& e) {
79399       {
79400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79401       };
79402     } catch (Dali::DaliException e) {
79403       {
79404         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79405       };
79406     } catch (...) {
79407       {
79408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79409       };
79410     }
79411   }
79412
79413 }
79414
79415
79416 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_set(void * jarg1, int jarg2) {
79417   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79418   Dali::Toolkit::SnapType arg2 ;
79419
79420   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79421   arg2 = (Dali::Toolkit::SnapType)jarg2;
79422   if (arg1) (arg1)->type = arg2;
79423 }
79424
79425
79426 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_get(void * jarg1) {
79427   int jresult ;
79428   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79429   Dali::Toolkit::SnapType result;
79430
79431   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79432   result = (Dali::Toolkit::SnapType) ((arg1)->type);
79433   jresult = (int)result;
79434   return jresult;
79435 }
79436
79437
79438 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_set(void * jarg1, void * jarg2) {
79439   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79440   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
79441
79442   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79443   arg2 = (Dali::Vector2 *)jarg2;
79444   if (arg1) (arg1)->position = *arg2;
79445 }
79446
79447
79448 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_get(void * jarg1) {
79449   void * jresult ;
79450   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79451   Dali::Vector2 *result = 0 ;
79452
79453   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79454   result = (Dali::Vector2 *)& ((arg1)->position);
79455   jresult = (void *)result;
79456   return jresult;
79457 }
79458
79459
79460 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_set(void * jarg1, float jarg2) {
79461   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79462   float arg2 ;
79463
79464   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79465   arg2 = (float)jarg2;
79466   if (arg1) (arg1)->duration = arg2;
79467 }
79468
79469
79470 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_get(void * jarg1) {
79471   float jresult ;
79472   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79473   float result;
79474
79475   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79476   result = (float) ((arg1)->duration);
79477   jresult = result;
79478   return jresult;
79479 }
79480
79481
79482 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_SnapEvent() {
79483   void * jresult ;
79484   Dali::Toolkit::ScrollView::SnapEvent *result = 0 ;
79485
79486   {
79487     try {
79488       result = (Dali::Toolkit::ScrollView::SnapEvent *)new Dali::Toolkit::ScrollView::SnapEvent();
79489     } catch (std::out_of_range& e) {
79490       {
79491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79492       };
79493     } catch (std::exception& e) {
79494       {
79495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79496       };
79497     } catch (Dali::DaliException e) {
79498       {
79499         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79500       };
79501     } catch (...) {
79502       {
79503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79504       };
79505     }
79506   }
79507
79508   jresult = (void *)result;
79509   return jresult;
79510 }
79511
79512
79513 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_SnapEvent(void * jarg1) {
79514   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79515
79516   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79517   {
79518     try {
79519       delete arg1;
79520     } catch (std::out_of_range& e) {
79521       {
79522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79523       };
79524     } catch (std::exception& e) {
79525       {
79526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79527       };
79528     } catch (Dali::DaliException e) {
79529       {
79530         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79531       };
79532     } catch (...) {
79533       {
79534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79535       };
79536     }
79537   }
79538
79539 }
79540
79541
79542 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_ENABLED_get() {
79543   int jresult ;
79544   int result;
79545
79546   result = (int)Dali::Toolkit::ScrollView::Property::WRAP_ENABLED;
79547   jresult = (int)result;
79548   return jresult;
79549 }
79550
79551
79552 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_ENABLED_get() {
79553   int jresult ;
79554   int result;
79555
79556   result = (int)Dali::Toolkit::ScrollView::Property::PANNING_ENABLED;
79557   jresult = (int)result;
79558   return jresult;
79559 }
79560
79561
79562 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_AXIS_AUTO_LOCK_ENABLED_get() {
79563   int jresult ;
79564   int result;
79565
79566   result = (int)Dali::Toolkit::ScrollView::Property::AXIS_AUTO_LOCK_ENABLED;
79567   jresult = (int)result;
79568   return jresult;
79569 }
79570
79571
79572 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
79573   int jresult ;
79574   int result;
79575
79576   result = (int)Dali::Toolkit::ScrollView::Property::WHEEL_SCROLL_DISTANCE_STEP;
79577   jresult = (int)result;
79578   return jresult;
79579 }
79580
79581
79582 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_MODE_get() {
79583   int jresult ;
79584   int result;
79585
79586   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_MODE;
79587   jresult = (int)result;
79588   return jresult;
79589 }
79590
79591 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_get() {
79592   int jresult ;
79593   int result;
79594
79595   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION;
79596   jresult = (int)result;
79597   return jresult;
79598 }
79599
79600
79601 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_get() {
79602   int jresult ;
79603   int result;
79604
79605   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION;
79606   jresult = (int)result;
79607   return jresult;
79608 }
79609
79610
79611 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_X_get() {
79612   int jresult ;
79613   int result;
79614
79615   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_X;
79616   jresult = (int)result;
79617   return jresult;
79618 }
79619
79620
79621 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_Y_get() {
79622   int jresult ;
79623   int result;
79624
79625   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_Y;
79626   jresult = (int)result;
79627   return jresult;
79628 }
79629
79630
79631 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_get() {
79632   int jresult ;
79633   int result;
79634
79635   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX;
79636   jresult = (int)result;
79637   return jresult;
79638 }
79639
79640
79641 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_X_get() {
79642   int jresult ;
79643   int result;
79644
79645   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_X;
79646   jresult = (int)result;
79647   return jresult;
79648 }
79649
79650
79651 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_Y_get() {
79652   int jresult ;
79653   int result;
79654
79655   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_Y;
79656   jresult = (int)result;
79657   return jresult;
79658 }
79659
79660
79661 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_X_get() {
79662   int jresult ;
79663   int result;
79664
79665   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_X;
79666   jresult = (int)result;
79667   return jresult;
79668 }
79669
79670
79671 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_Y_get() {
79672   int jresult ;
79673   int result;
79674
79675   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_Y;
79676   jresult = (int)result;
79677   return jresult;
79678 }
79679
79680
79681 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_get() {
79682   int jresult ;
79683   int result;
79684
79685   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL;
79686   jresult = (int)result;
79687   return jresult;
79688 }
79689
79690
79691 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_X_get() {
79692   int jresult ;
79693   int result;
79694
79695   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_X;
79696   jresult = (int)result;
79697   return jresult;
79698 }
79699
79700
79701 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_Y_get() {
79702   int jresult ;
79703   int result;
79704
79705   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_Y;
79706   jresult = (int)result;
79707   return jresult;
79708 }
79709
79710
79711 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_get() {
79712   int jresult ;
79713   int result;
79714
79715   result = (int)Dali::Toolkit::ScrollView::Property::WRAP;
79716   jresult = (int)result;
79717   return jresult;
79718 }
79719
79720
79721 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_get() {
79722   int jresult ;
79723   int result;
79724
79725   result = (int)Dali::Toolkit::ScrollView::Property::PANNING;
79726   jresult = (int)result;
79727   return jresult;
79728 }
79729
79730
79731 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLLING_get() {
79732   int jresult ;
79733   int result;
79734
79735   result = (int)Dali::Toolkit::ScrollView::Property::SCROLLING;
79736   jresult = (int)result;
79737   return jresult;
79738 }
79739
79740
79741 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_get() {
79742   int jresult ;
79743   int result;
79744
79745   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE;
79746   jresult = (int)result;
79747   return jresult;
79748 }
79749
79750
79751 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_X_get() {
79752   int jresult ;
79753   int result;
79754
79755   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_X;
79756   jresult = (int)result;
79757   return jresult;
79758 }
79759
79760
79761 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_Y_get() {
79762   int jresult ;
79763   int result;
79764
79765   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_Y;
79766   jresult = (int)result;
79767   return jresult;
79768 }
79769
79770
79771 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_OFFSET_get() {
79772   int jresult ;
79773   int result;
79774
79775   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_OFFSET;
79776   jresult = (int)result;
79777   return jresult;
79778 }
79779
79780
79781 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_DELTA_get() {
79782   int jresult ;
79783   int result;
79784
79785   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION_DELTA;
79786   jresult = (int)result;
79787   return jresult;
79788 }
79789
79790
79791 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_START_PAGE_POSITION_get() {
79792   int jresult ;
79793   int result;
79794
79795   result = (int)Dali::Toolkit::ScrollView::Property::START_PAGE_POSITION;
79796   jresult = (int)result;
79797   return jresult;
79798 }
79799
79800
79801 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_Property() {
79802   void * jresult ;
79803   Dali::Toolkit::ScrollView::Property *result = 0 ;
79804
79805   {
79806     try {
79807       result = (Dali::Toolkit::ScrollView::Property *)new Dali::Toolkit::ScrollView::Property();
79808     } catch (std::out_of_range& e) {
79809       {
79810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79811       };
79812     } catch (std::exception& e) {
79813       {
79814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79815       };
79816     } catch (Dali::DaliException e) {
79817       {
79818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79819       };
79820     } catch (...) {
79821       {
79822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79823       };
79824     }
79825   }
79826
79827   jresult = (void *)result;
79828   return jresult;
79829 }
79830
79831
79832 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_Property(void * jarg1) {
79833   Dali::Toolkit::ScrollView::Property *arg1 = (Dali::Toolkit::ScrollView::Property *) 0 ;
79834
79835   arg1 = (Dali::Toolkit::ScrollView::Property *)jarg1;
79836   {
79837     try {
79838       delete arg1;
79839     } catch (std::out_of_range& e) {
79840       {
79841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79842       };
79843     } catch (std::exception& e) {
79844       {
79845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79846       };
79847     } catch (Dali::DaliException e) {
79848       {
79849         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79850       };
79851     } catch (...) {
79852       {
79853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79854       };
79855     }
79856   }
79857
79858 }
79859
79860
79861 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_0() {
79862   void * jresult ;
79863   Dali::Toolkit::ScrollView *result = 0 ;
79864
79865   {
79866     try {
79867       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView();
79868     } catch (std::out_of_range& e) {
79869       {
79870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79871       };
79872     } catch (std::exception& e) {
79873       {
79874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79875       };
79876     } catch (Dali::DaliException e) {
79877       {
79878         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79879       };
79880     } catch (...) {
79881       {
79882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79883       };
79884     }
79885   }
79886
79887   jresult = (void *)result;
79888   return jresult;
79889 }
79890
79891
79892 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_1(void * jarg1) {
79893   void * jresult ;
79894   Dali::Toolkit::ScrollView *arg1 = 0 ;
79895   Dali::Toolkit::ScrollView *result = 0 ;
79896
79897   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79898   if (!arg1) {
79899     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
79900     return 0;
79901   }
79902   {
79903     try {
79904       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView((Dali::Toolkit::ScrollView const &)*arg1);
79905     } catch (std::out_of_range& e) {
79906       {
79907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79908       };
79909     } catch (std::exception& e) {
79910       {
79911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79912       };
79913     } catch (Dali::DaliException e) {
79914       {
79915         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79916       };
79917     } catch (...) {
79918       {
79919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79920       };
79921     }
79922   }
79923
79924   jresult = (void *)result;
79925   return jresult;
79926 }
79927
79928
79929 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_Assign(void * jarg1, void * jarg2) {
79930   void * jresult ;
79931   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79932   Dali::Toolkit::ScrollView *arg2 = 0 ;
79933   Dali::Toolkit::ScrollView *result = 0 ;
79934
79935   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79936   arg2 = (Dali::Toolkit::ScrollView *)jarg2;
79937   if (!arg2) {
79938     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
79939     return 0;
79940   }
79941   {
79942     try {
79943       result = (Dali::Toolkit::ScrollView *) &(arg1)->operator =((Dali::Toolkit::ScrollView const &)*arg2);
79944     } catch (std::out_of_range& e) {
79945       {
79946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79947       };
79948     } catch (std::exception& e) {
79949       {
79950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79951       };
79952     } catch (Dali::DaliException e) {
79953       {
79954         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79955       };
79956     } catch (...) {
79957       {
79958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79959       };
79960     }
79961   }
79962
79963   jresult = (void *)result;
79964   return jresult;
79965 }
79966
79967
79968 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView(void * jarg1) {
79969   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79970
79971   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79972   {
79973     try {
79974       delete arg1;
79975     } catch (std::out_of_range& e) {
79976       {
79977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79978       };
79979     } catch (std::exception& e) {
79980       {
79981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79982       };
79983     } catch (Dali::DaliException e) {
79984       {
79985         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79986       };
79987     } catch (...) {
79988       {
79989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79990       };
79991     }
79992   }
79993
79994 }
79995
79996
79997 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_New() {
79998   void * jresult ;
79999   Dali::Toolkit::ScrollView result;
80000
80001   {
80002     try {
80003       result = Dali::Toolkit::ScrollView::New();
80004     } catch (std::out_of_range& e) {
80005       {
80006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80007       };
80008     } catch (std::exception& e) {
80009       {
80010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80011       };
80012     } catch (Dali::DaliException e) {
80013       {
80014         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80015       };
80016     } catch (...) {
80017       {
80018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80019       };
80020     }
80021   }
80022
80023   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
80024   return jresult;
80025 }
80026
80027
80028 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_DownCast(void * jarg1) {
80029   void * jresult ;
80030   Dali::BaseHandle arg1 ;
80031   Dali::BaseHandle *argp1 ;
80032   Dali::Toolkit::ScrollView result;
80033
80034   argp1 = (Dali::BaseHandle *)jarg1;
80035   if (!argp1) {
80036     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
80037     return 0;
80038   }
80039   arg1 = *argp1;
80040   {
80041     try {
80042       result = Dali::Toolkit::ScrollView::DownCast(arg1);
80043     } catch (std::out_of_range& e) {
80044       {
80045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80046       };
80047     } catch (std::exception& e) {
80048       {
80049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80050       };
80051     } catch (Dali::DaliException e) {
80052       {
80053         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80054       };
80055     } catch (...) {
80056       {
80057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80058       };
80059     }
80060   }
80061
80062   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
80063   return jresult;
80064 }
80065
80066
80067 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapAlphaFunction(void * jarg1) {
80068   void * jresult ;
80069   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80070   Dali::AlphaFunction result;
80071
80072   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80073   {
80074     try {
80075       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapAlphaFunction();
80076     } catch (std::out_of_range& e) {
80077       {
80078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80079       };
80080     } catch (std::exception& e) {
80081       {
80082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80083       };
80084     } catch (Dali::DaliException e) {
80085       {
80086         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80087       };
80088     } catch (...) {
80089       {
80090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80091       };
80092     }
80093   }
80094
80095   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
80096   return jresult;
80097 }
80098
80099
80100 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapAlphaFunction(void * jarg1, void * jarg2) {
80101   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80102   Dali::AlphaFunction arg2 ;
80103   Dali::AlphaFunction *argp2 ;
80104
80105   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80106   argp2 = (Dali::AlphaFunction *)jarg2;
80107   if (!argp2) {
80108     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
80109     return ;
80110   }
80111   arg2 = *argp2;
80112   {
80113     try {
80114       (arg1)->SetScrollSnapAlphaFunction(arg2);
80115     } catch (std::out_of_range& e) {
80116       {
80117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80118       };
80119     } catch (std::exception& e) {
80120       {
80121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80122       };
80123     } catch (Dali::DaliException e) {
80124       {
80125         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80126       };
80127     } catch (...) {
80128       {
80129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80130       };
80131     }
80132   }
80133
80134 }
80135
80136
80137 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickAlphaFunction(void * jarg1) {
80138   void * jresult ;
80139   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80140   Dali::AlphaFunction result;
80141
80142   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80143   {
80144     try {
80145       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickAlphaFunction();
80146     } catch (std::out_of_range& e) {
80147       {
80148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80149       };
80150     } catch (std::exception& e) {
80151       {
80152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80153       };
80154     } catch (Dali::DaliException e) {
80155       {
80156         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80157       };
80158     } catch (...) {
80159       {
80160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80161       };
80162     }
80163   }
80164
80165   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
80166   return jresult;
80167 }
80168
80169
80170 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickAlphaFunction(void * jarg1, void * jarg2) {
80171   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80172   Dali::AlphaFunction arg2 ;
80173   Dali::AlphaFunction *argp2 ;
80174
80175   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80176   argp2 = (Dali::AlphaFunction *)jarg2;
80177   if (!argp2) {
80178     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
80179     return ;
80180   }
80181   arg2 = *argp2;
80182   {
80183     try {
80184       (arg1)->SetScrollFlickAlphaFunction(arg2);
80185     } catch (std::out_of_range& e) {
80186       {
80187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80188       };
80189     } catch (std::exception& e) {
80190       {
80191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80192       };
80193     } catch (Dali::DaliException e) {
80194       {
80195         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80196       };
80197     } catch (...) {
80198       {
80199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80200       };
80201     }
80202   }
80203
80204 }
80205
80206
80207 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapDuration(void * jarg1) {
80208   float jresult ;
80209   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80210   float result;
80211
80212   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80213   {
80214     try {
80215       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapDuration();
80216     } catch (std::out_of_range& e) {
80217       {
80218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80219       };
80220     } catch (std::exception& e) {
80221       {
80222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80223       };
80224     } catch (Dali::DaliException e) {
80225       {
80226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80227       };
80228     } catch (...) {
80229       {
80230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80231       };
80232     }
80233   }
80234
80235   jresult = result;
80236   return jresult;
80237 }
80238
80239
80240 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapDuration(void * jarg1, float jarg2) {
80241   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80242   float arg2 ;
80243
80244   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80245   arg2 = (float)jarg2;
80246   {
80247     try {
80248       (arg1)->SetScrollSnapDuration(arg2);
80249     } catch (std::out_of_range& e) {
80250       {
80251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80252       };
80253     } catch (std::exception& e) {
80254       {
80255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80256       };
80257     } catch (Dali::DaliException e) {
80258       {
80259         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80260       };
80261     } catch (...) {
80262       {
80263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80264       };
80265     }
80266   }
80267
80268 }
80269
80270
80271 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickDuration(void * jarg1) {
80272   float jresult ;
80273   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80274   float result;
80275
80276   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80277   {
80278     try {
80279       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickDuration();
80280     } catch (std::out_of_range& e) {
80281       {
80282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80283       };
80284     } catch (std::exception& e) {
80285       {
80286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80287       };
80288     } catch (Dali::DaliException e) {
80289       {
80290         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80291       };
80292     } catch (...) {
80293       {
80294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80295       };
80296     }
80297   }
80298
80299   jresult = result;
80300   return jresult;
80301 }
80302
80303
80304 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickDuration(void * jarg1, float jarg2) {
80305   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80306   float arg2 ;
80307
80308   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80309   arg2 = (float)jarg2;
80310   {
80311     try {
80312       (arg1)->SetScrollFlickDuration(arg2);
80313     } catch (std::out_of_range& e) {
80314       {
80315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80316       };
80317     } catch (std::exception& e) {
80318       {
80319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80320       };
80321     } catch (Dali::DaliException e) {
80322       {
80323         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80324       };
80325     } catch (...) {
80326       {
80327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80328       };
80329     }
80330   }
80331
80332 }
80333
80334
80335 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerX(void * jarg1, void * jarg2) {
80336   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80337   Dali::Toolkit::RulerPtr arg2 ;
80338   Dali::Toolkit::RulerPtr *argp2 ;
80339
80340   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80341   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
80342   if (!argp2) {
80343     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
80344     return ;
80345   }
80346   arg2 = *argp2;
80347   {
80348     try {
80349       (arg1)->SetRulerX(arg2);
80350     } catch (std::out_of_range& e) {
80351       {
80352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80353       };
80354     } catch (std::exception& e) {
80355       {
80356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80357       };
80358     } catch (Dali::DaliException e) {
80359       {
80360         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80361       };
80362     } catch (...) {
80363       {
80364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80365       };
80366     }
80367   }
80368
80369 }
80370
80371
80372 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerY(void * jarg1, void * jarg2) {
80373   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80374   Dali::Toolkit::RulerPtr arg2 ;
80375   Dali::Toolkit::RulerPtr *argp2 ;
80376
80377   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80378   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
80379   if (!argp2) {
80380     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
80381     return ;
80382   }
80383   arg2 = *argp2;
80384   {
80385     try {
80386       (arg1)->SetRulerY(arg2);
80387     } catch (std::out_of_range& e) {
80388       {
80389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80390       };
80391     } catch (std::exception& e) {
80392       {
80393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80394       };
80395     } catch (Dali::DaliException e) {
80396       {
80397         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80398       };
80399     } catch (...) {
80400       {
80401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80402       };
80403     }
80404   }
80405
80406 }
80407
80408
80409 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSensitive(void * jarg1, unsigned int jarg2) {
80410   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80411   bool arg2 ;
80412
80413   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80414   arg2 = jarg2 ? true : false;
80415   {
80416     try {
80417       (arg1)->SetScrollSensitive(arg2);
80418     } catch (std::out_of_range& e) {
80419       {
80420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80421       };
80422     } catch (std::exception& e) {
80423       {
80424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80425       };
80426     } catch (Dali::DaliException e) {
80427       {
80428         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80429       };
80430     } catch (...) {
80431       {
80432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80433       };
80434     }
80435   }
80436
80437 }
80438
80439
80440 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxOvershoot(void * jarg1, float jarg2, float jarg3) {
80441   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80442   float arg2 ;
80443   float arg3 ;
80444
80445   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80446   arg2 = (float)jarg2;
80447   arg3 = (float)jarg3;
80448   {
80449     try {
80450       (arg1)->SetMaxOvershoot(arg2,arg3);
80451     } catch (std::out_of_range& e) {
80452       {
80453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80454       };
80455     } catch (std::exception& e) {
80456       {
80457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80458       };
80459     } catch (Dali::DaliException e) {
80460       {
80461         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80462       };
80463     } catch (...) {
80464       {
80465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80466       };
80467     }
80468   }
80469
80470 }
80471
80472
80473 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootAlphaFunction(void * jarg1, void * jarg2) {
80474   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80475   Dali::AlphaFunction arg2 ;
80476   Dali::AlphaFunction *argp2 ;
80477
80478   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80479   argp2 = (Dali::AlphaFunction *)jarg2;
80480   if (!argp2) {
80481     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
80482     return ;
80483   }
80484   arg2 = *argp2;
80485   {
80486     try {
80487       (arg1)->SetSnapOvershootAlphaFunction(arg2);
80488     } catch (std::out_of_range& e) {
80489       {
80490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80491       };
80492     } catch (std::exception& e) {
80493       {
80494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80495       };
80496     } catch (Dali::DaliException e) {
80497       {
80498         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80499       };
80500     } catch (...) {
80501       {
80502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80503       };
80504     }
80505   }
80506
80507 }
80508
80509
80510 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootDuration(void * jarg1, float jarg2) {
80511   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80512   float arg2 ;
80513
80514   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80515   arg2 = (float)jarg2;
80516   {
80517     try {
80518       (arg1)->SetSnapOvershootDuration(arg2);
80519     } catch (std::out_of_range& e) {
80520       {
80521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80522       };
80523     } catch (std::exception& e) {
80524       {
80525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80526       };
80527     } catch (Dali::DaliException e) {
80528       {
80529         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80530       };
80531     } catch (...) {
80532       {
80533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80534       };
80535     }
80536   }
80537
80538 }
80539
80540
80541 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetActorAutoSnap(void * jarg1, unsigned int jarg2) {
80542   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80543   bool arg2 ;
80544
80545   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80546   arg2 = jarg2 ? true : false;
80547   {
80548     try {
80549       (arg1)->SetActorAutoSnap(arg2);
80550     } catch (std::out_of_range& e) {
80551       {
80552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80553       };
80554     } catch (std::exception& e) {
80555       {
80556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80557       };
80558     } catch (Dali::DaliException e) {
80559       {
80560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80561       };
80562     } catch (...) {
80563       {
80564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80565       };
80566     }
80567   }
80568
80569 }
80570
80571
80572 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWrapMode(void * jarg1, unsigned int jarg2) {
80573   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80574   bool arg2 ;
80575
80576   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80577   arg2 = jarg2 ? true : false;
80578   {
80579     try {
80580       (arg1)->SetWrapMode(arg2);
80581     } catch (std::out_of_range& e) {
80582       {
80583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80584       };
80585     } catch (std::exception& e) {
80586       {
80587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80588       };
80589     } catch (Dali::DaliException e) {
80590       {
80591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80592       };
80593     } catch (...) {
80594       {
80595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80596       };
80597     }
80598   }
80599
80600 }
80601
80602
80603 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollUpdateDistance(void * jarg1) {
80604   int jresult ;
80605   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80606   int result;
80607
80608   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80609   {
80610     try {
80611       result = (int)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollUpdateDistance();
80612     } catch (std::out_of_range& e) {
80613       {
80614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80615       };
80616     } catch (std::exception& e) {
80617       {
80618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80619       };
80620     } catch (Dali::DaliException e) {
80621       {
80622         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80623       };
80624     } catch (...) {
80625       {
80626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80627       };
80628     }
80629   }
80630
80631   jresult = result;
80632   return jresult;
80633 }
80634
80635
80636 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollUpdateDistance(void * jarg1, int jarg2) {
80637   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80638   int arg2 ;
80639
80640   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80641   arg2 = (int)jarg2;
80642   {
80643     try {
80644       (arg1)->SetScrollUpdateDistance(arg2);
80645     } catch (std::out_of_range& e) {
80646       {
80647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80648       };
80649     } catch (std::exception& e) {
80650       {
80651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80652       };
80653     } catch (Dali::DaliException e) {
80654       {
80655         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80656       };
80657     } catch (...) {
80658       {
80659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80660       };
80661     }
80662   }
80663
80664 }
80665
80666
80667 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLock(void * jarg1) {
80668   unsigned int jresult ;
80669   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80670   bool result;
80671
80672   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80673   {
80674     try {
80675       result = (bool)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLock();
80676     } catch (std::out_of_range& e) {
80677       {
80678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80679       };
80680     } catch (std::exception& e) {
80681       {
80682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80683       };
80684     } catch (Dali::DaliException e) {
80685       {
80686         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80687       };
80688     } catch (...) {
80689       {
80690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80691       };
80692     }
80693   }
80694
80695   jresult = result;
80696   return jresult;
80697 }
80698
80699
80700 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLock(void * jarg1, unsigned int jarg2) {
80701   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80702   bool arg2 ;
80703
80704   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80705   arg2 = jarg2 ? true : false;
80706   {
80707     try {
80708       (arg1)->SetAxisAutoLock(arg2);
80709     } catch (std::out_of_range& e) {
80710       {
80711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80712       };
80713     } catch (std::exception& e) {
80714       {
80715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80716       };
80717     } catch (Dali::DaliException e) {
80718       {
80719         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80720       };
80721     } catch (...) {
80722       {
80723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80724       };
80725     }
80726   }
80727
80728 }
80729
80730
80731 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLockGradient(void * jarg1) {
80732   float jresult ;
80733   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80734   float result;
80735
80736   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80737   {
80738     try {
80739       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLockGradient();
80740     } catch (std::out_of_range& e) {
80741       {
80742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80743       };
80744     } catch (std::exception& e) {
80745       {
80746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80747       };
80748     } catch (Dali::DaliException e) {
80749       {
80750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80751       };
80752     } catch (...) {
80753       {
80754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80755       };
80756     }
80757   }
80758
80759   jresult = result;
80760   return jresult;
80761 }
80762
80763
80764 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLockGradient(void * jarg1, float jarg2) {
80765   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80766   float arg2 ;
80767
80768   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80769   arg2 = (float)jarg2;
80770   {
80771     try {
80772       (arg1)->SetAxisAutoLockGradient(arg2);
80773     } catch (std::out_of_range& e) {
80774       {
80775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80776       };
80777     } catch (std::exception& e) {
80778       {
80779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80780       };
80781     } catch (Dali::DaliException e) {
80782       {
80783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80784       };
80785     } catch (...) {
80786       {
80787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80788       };
80789     }
80790   }
80791
80792 }
80793
80794
80795 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFrictionCoefficient(void * jarg1) {
80796   float jresult ;
80797   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80798   float result;
80799
80800   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80801   {
80802     try {
80803       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFrictionCoefficient();
80804     } catch (std::out_of_range& e) {
80805       {
80806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80807       };
80808     } catch (std::exception& e) {
80809       {
80810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80811       };
80812     } catch (Dali::DaliException e) {
80813       {
80814         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80815       };
80816     } catch (...) {
80817       {
80818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80819       };
80820     }
80821   }
80822
80823   jresult = result;
80824   return jresult;
80825 }
80826
80827
80828 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFrictionCoefficient(void * jarg1, float jarg2) {
80829   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80830   float arg2 ;
80831
80832   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80833   arg2 = (float)jarg2;
80834   {
80835     try {
80836       (arg1)->SetFrictionCoefficient(arg2);
80837     } catch (std::out_of_range& e) {
80838       {
80839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80840       };
80841     } catch (std::exception& e) {
80842       {
80843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80844       };
80845     } catch (Dali::DaliException e) {
80846       {
80847         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80848       };
80849     } catch (...) {
80850       {
80851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80852       };
80853     }
80854   }
80855
80856 }
80857
80858
80859 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFlickSpeedCoefficient(void * jarg1) {
80860   float jresult ;
80861   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80862   float result;
80863
80864   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80865   {
80866     try {
80867       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFlickSpeedCoefficient();
80868     } catch (std::out_of_range& e) {
80869       {
80870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80871       };
80872     } catch (std::exception& e) {
80873       {
80874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80875       };
80876     } catch (Dali::DaliException e) {
80877       {
80878         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80879       };
80880     } catch (...) {
80881       {
80882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80883       };
80884     }
80885   }
80886
80887   jresult = result;
80888   return jresult;
80889 }
80890
80891
80892 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFlickSpeedCoefficient(void * jarg1, float jarg2) {
80893   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80894   float arg2 ;
80895
80896   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80897   arg2 = (float)jarg2;
80898   {
80899     try {
80900       (arg1)->SetFlickSpeedCoefficient(arg2);
80901     } catch (std::out_of_range& e) {
80902       {
80903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80904       };
80905     } catch (std::exception& e) {
80906       {
80907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80908       };
80909     } catch (Dali::DaliException e) {
80910       {
80911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80912       };
80913     } catch (...) {
80914       {
80915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80916       };
80917     }
80918   }
80919
80920 }
80921
80922
80923 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumDistanceForFlick(void * jarg1) {
80924   void * jresult ;
80925   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80926   Dali::Vector2 result;
80927
80928   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80929   {
80930     try {
80931       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumDistanceForFlick();
80932     } catch (std::out_of_range& e) {
80933       {
80934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80935       };
80936     } catch (std::exception& e) {
80937       {
80938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80939       };
80940     } catch (Dali::DaliException e) {
80941       {
80942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80943       };
80944     } catch (...) {
80945       {
80946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80947       };
80948     }
80949   }
80950
80951   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
80952   return jresult;
80953 }
80954
80955
80956 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumDistanceForFlick(void * jarg1, void * jarg2) {
80957   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80958   Dali::Vector2 *arg2 = 0 ;
80959
80960   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80961   arg2 = (Dali::Vector2 *)jarg2;
80962   if (!arg2) {
80963     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
80964     return ;
80965   }
80966   {
80967     try {
80968       (arg1)->SetMinimumDistanceForFlick((Dali::Vector2 const &)*arg2);
80969     } catch (std::out_of_range& e) {
80970       {
80971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80972       };
80973     } catch (std::exception& e) {
80974       {
80975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80976       };
80977     } catch (Dali::DaliException e) {
80978       {
80979         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80980       };
80981     } catch (...) {
80982       {
80983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80984       };
80985     }
80986   }
80987
80988 }
80989
80990
80991 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumSpeedForFlick(void * jarg1) {
80992   float jresult ;
80993   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80994   float result;
80995
80996   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80997   {
80998     try {
80999       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumSpeedForFlick();
81000     } catch (std::out_of_range& e) {
81001       {
81002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81003       };
81004     } catch (std::exception& e) {
81005       {
81006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81007       };
81008     } catch (Dali::DaliException e) {
81009       {
81010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81011       };
81012     } catch (...) {
81013       {
81014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81015       };
81016     }
81017   }
81018
81019   jresult = result;
81020   return jresult;
81021 }
81022
81023
81024 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumSpeedForFlick(void * jarg1, float jarg2) {
81025   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81026   float arg2 ;
81027
81028   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81029   arg2 = (float)jarg2;
81030   {
81031     try {
81032       (arg1)->SetMinimumSpeedForFlick(arg2);
81033     } catch (std::out_of_range& e) {
81034       {
81035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81036       };
81037     } catch (std::exception& e) {
81038       {
81039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81040       };
81041     } catch (Dali::DaliException e) {
81042       {
81043         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81044       };
81045     } catch (...) {
81046       {
81047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81048       };
81049     }
81050   }
81051
81052 }
81053
81054
81055 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMaxFlickSpeed(void * jarg1) {
81056   float jresult ;
81057   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81058   float result;
81059
81060   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81061   {
81062     try {
81063       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMaxFlickSpeed();
81064     } catch (std::out_of_range& e) {
81065       {
81066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81067       };
81068     } catch (std::exception& e) {
81069       {
81070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81071       };
81072     } catch (Dali::DaliException e) {
81073       {
81074         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81075       };
81076     } catch (...) {
81077       {
81078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81079       };
81080     }
81081   }
81082
81083   jresult = result;
81084   return jresult;
81085 }
81086
81087
81088 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxFlickSpeed(void * jarg1, float jarg2) {
81089   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81090   float arg2 ;
81091
81092   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81093   arg2 = (float)jarg2;
81094   {
81095     try {
81096       (arg1)->SetMaxFlickSpeed(arg2);
81097     } catch (std::out_of_range& e) {
81098       {
81099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81100       };
81101     } catch (std::exception& e) {
81102       {
81103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81104       };
81105     } catch (Dali::DaliException e) {
81106       {
81107         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81108       };
81109     } catch (...) {
81110       {
81111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81112       };
81113     }
81114   }
81115
81116 }
81117
81118
81119 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetWheelScrollDistanceStep(void * jarg1) {
81120   void * jresult ;
81121   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81122   Dali::Vector2 result;
81123
81124   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81125   {
81126     try {
81127       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetWheelScrollDistanceStep();
81128     } catch (std::out_of_range& e) {
81129       {
81130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81131       };
81132     } catch (std::exception& e) {
81133       {
81134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81135       };
81136     } catch (Dali::DaliException e) {
81137       {
81138         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81139       };
81140     } catch (...) {
81141       {
81142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81143       };
81144     }
81145   }
81146
81147   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
81148   return jresult;
81149 }
81150
81151
81152 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWheelScrollDistanceStep(void * jarg1, void * jarg2) {
81153   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81154   Dali::Vector2 arg2 ;
81155   Dali::Vector2 *argp2 ;
81156
81157   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81158   argp2 = (Dali::Vector2 *)jarg2;
81159   if (!argp2) {
81160     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
81161     return ;
81162   }
81163   arg2 = *argp2;
81164   {
81165     try {
81166       (arg1)->SetWheelScrollDistanceStep(arg2);
81167     } catch (std::out_of_range& e) {
81168       {
81169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81170       };
81171     } catch (std::exception& e) {
81172       {
81173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81174       };
81175     } catch (Dali::DaliException e) {
81176       {
81177         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81178       };
81179     } catch (...) {
81180       {
81181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81182       };
81183     }
81184   }
81185
81186 }
81187
81188
81189 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentScrollPosition(void * jarg1) {
81190   void * jresult ;
81191   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81192   Dali::Vector2 result;
81193
81194   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81195   {
81196     try {
81197       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentScrollPosition();
81198     } catch (std::out_of_range& e) {
81199       {
81200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81201       };
81202     } catch (std::exception& e) {
81203       {
81204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81205       };
81206     } catch (Dali::DaliException e) {
81207       {
81208         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81209       };
81210     } catch (...) {
81211       {
81212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81213       };
81214     }
81215   }
81216
81217   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
81218   return jresult;
81219 }
81220
81221
81222 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentPage(void * jarg1) {
81223   unsigned int jresult ;
81224   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81225   unsigned int result;
81226
81227   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81228   {
81229     try {
81230       result = (unsigned int)((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentPage();
81231     } catch (std::out_of_range& e) {
81232       {
81233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81234       };
81235     } catch (std::exception& e) {
81236       {
81237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81238       };
81239     } catch (Dali::DaliException e) {
81240       {
81241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81242       };
81243     } catch (...) {
81244       {
81245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81246       };
81247     }
81248   }
81249
81250   jresult = result;
81251   return jresult;
81252 }
81253
81254
81255 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_0(void * jarg1, void * jarg2) {
81256   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81257   Dali::Vector2 *arg2 = 0 ;
81258
81259   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81260   arg2 = (Dali::Vector2 *)jarg2;
81261   if (!arg2) {
81262     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81263     return ;
81264   }
81265   {
81266     try {
81267       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2);
81268     } catch (std::out_of_range& e) {
81269       {
81270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81271       };
81272     } catch (std::exception& e) {
81273       {
81274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81275       };
81276     } catch (Dali::DaliException e) {
81277       {
81278         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81279       };
81280     } catch (...) {
81281       {
81282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81283       };
81284     }
81285   }
81286
81287 }
81288
81289
81290 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
81291   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81292   Dali::Vector2 *arg2 = 0 ;
81293   float arg3 ;
81294
81295   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81296   arg2 = (Dali::Vector2 *)jarg2;
81297   if (!arg2) {
81298     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81299     return ;
81300   }
81301   arg3 = (float)jarg3;
81302   {
81303     try {
81304       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3);
81305     } catch (std::out_of_range& e) {
81306       {
81307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81308       };
81309     } catch (std::exception& e) {
81310       {
81311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81312       };
81313     } catch (Dali::DaliException e) {
81314       {
81315         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81316       };
81317     } catch (...) {
81318       {
81319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81320       };
81321     }
81322   }
81323
81324 }
81325
81326
81327 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_2(void * jarg1, void * jarg2, float jarg3, void * jarg4) {
81328   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81329   Dali::Vector2 *arg2 = 0 ;
81330   float arg3 ;
81331   Dali::AlphaFunction arg4 ;
81332   Dali::AlphaFunction *argp4 ;
81333
81334   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81335   arg2 = (Dali::Vector2 *)jarg2;
81336   if (!arg2) {
81337     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81338     return ;
81339   }
81340   arg3 = (float)jarg3;
81341   argp4 = (Dali::AlphaFunction *)jarg4;
81342   if (!argp4) {
81343     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
81344     return ;
81345   }
81346   arg4 = *argp4;
81347   {
81348     try {
81349       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4);
81350     } catch (std::out_of_range& e) {
81351       {
81352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81353       };
81354     } catch (std::exception& e) {
81355       {
81356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81357       };
81358     } catch (Dali::DaliException e) {
81359       {
81360         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81361       };
81362     } catch (...) {
81363       {
81364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81365       };
81366     }
81367   }
81368
81369 }
81370
81371
81372 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_3(void * jarg1, void * jarg2, float jarg3, int jarg4, int jarg5) {
81373   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81374   Dali::Vector2 *arg2 = 0 ;
81375   float arg3 ;
81376   Dali::Toolkit::DirectionBias arg4 ;
81377   Dali::Toolkit::DirectionBias arg5 ;
81378
81379   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81380   arg2 = (Dali::Vector2 *)jarg2;
81381   if (!arg2) {
81382     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81383     return ;
81384   }
81385   arg3 = (float)jarg3;
81386   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
81387   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
81388   {
81389     try {
81390       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5);
81391     } catch (std::out_of_range& e) {
81392       {
81393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81394       };
81395     } catch (std::exception& e) {
81396       {
81397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81398       };
81399     } catch (Dali::DaliException e) {
81400       {
81401         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81402       };
81403     } catch (...) {
81404       {
81405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81406       };
81407     }
81408   }
81409
81410 }
81411
81412
81413 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_4(void * jarg1, void * jarg2, float jarg3, void * jarg4, int jarg5, int jarg6) {
81414   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81415   Dali::Vector2 *arg2 = 0 ;
81416   float arg3 ;
81417   Dali::AlphaFunction arg4 ;
81418   Dali::Toolkit::DirectionBias arg5 ;
81419   Dali::Toolkit::DirectionBias arg6 ;
81420   Dali::AlphaFunction *argp4 ;
81421
81422   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81423   arg2 = (Dali::Vector2 *)jarg2;
81424   if (!arg2) {
81425     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81426     return ;
81427   }
81428   arg3 = (float)jarg3;
81429   argp4 = (Dali::AlphaFunction *)jarg4;
81430   if (!argp4) {
81431     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
81432     return ;
81433   }
81434   arg4 = *argp4;
81435   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
81436   arg6 = (Dali::Toolkit::DirectionBias)jarg6;
81437   {
81438     try {
81439       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5,arg6);
81440     } catch (std::out_of_range& e) {
81441       {
81442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81443       };
81444     } catch (std::exception& e) {
81445       {
81446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81447       };
81448     } catch (Dali::DaliException e) {
81449       {
81450         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81451       };
81452     } catch (...) {
81453       {
81454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81455       };
81456     }
81457   }
81458
81459 }
81460
81461
81462 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_5(void * jarg1, unsigned int jarg2) {
81463   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81464   unsigned int arg2 ;
81465
81466   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81467   arg2 = (unsigned int)jarg2;
81468   {
81469     try {
81470       (arg1)->ScrollTo(arg2);
81471     } catch (std::out_of_range& e) {
81472       {
81473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81474       };
81475     } catch (std::exception& e) {
81476       {
81477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81478       };
81479     } catch (Dali::DaliException e) {
81480       {
81481         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81482       };
81483     } catch (...) {
81484       {
81485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81486       };
81487     }
81488   }
81489
81490 }
81491
81492
81493 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_6(void * jarg1, unsigned int jarg2, float jarg3) {
81494   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81495   unsigned int arg2 ;
81496   float arg3 ;
81497
81498   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81499   arg2 = (unsigned int)jarg2;
81500   arg3 = (float)jarg3;
81501   {
81502     try {
81503       (arg1)->ScrollTo(arg2,arg3);
81504     } catch (std::out_of_range& e) {
81505       {
81506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81507       };
81508     } catch (std::exception& e) {
81509       {
81510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81511       };
81512     } catch (Dali::DaliException e) {
81513       {
81514         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81515       };
81516     } catch (...) {
81517       {
81518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81519       };
81520     }
81521   }
81522
81523 }
81524
81525
81526 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_7(void * jarg1, unsigned int jarg2, float jarg3, int jarg4) {
81527   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81528   unsigned int arg2 ;
81529   float arg3 ;
81530   Dali::Toolkit::DirectionBias arg4 ;
81531
81532   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81533   arg2 = (unsigned int)jarg2;
81534   arg3 = (float)jarg3;
81535   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
81536   {
81537     try {
81538       (arg1)->ScrollTo(arg2,arg3,arg4);
81539     } catch (std::out_of_range& e) {
81540       {
81541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81542       };
81543     } catch (std::exception& e) {
81544       {
81545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81546       };
81547     } catch (Dali::DaliException e) {
81548       {
81549         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81550       };
81551     } catch (...) {
81552       {
81553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81554       };
81555     }
81556   }
81557
81558 }
81559
81560
81561 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_8(void * jarg1, void * jarg2) {
81562   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81563   Dali::Actor *arg2 = 0 ;
81564
81565   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81566   arg2 = (Dali::Actor *)jarg2;
81567   if (!arg2) {
81568     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
81569     return ;
81570   }
81571   {
81572     try {
81573       (arg1)->ScrollTo(*arg2);
81574     } catch (std::out_of_range& e) {
81575       {
81576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81577       };
81578     } catch (std::exception& e) {
81579       {
81580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81581       };
81582     } catch (Dali::DaliException e) {
81583       {
81584         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81585       };
81586     } catch (...) {
81587       {
81588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81589       };
81590     }
81591   }
81592
81593 }
81594
81595
81596 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_9(void * jarg1, void * jarg2, float jarg3) {
81597   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81598   Dali::Actor *arg2 = 0 ;
81599   float arg3 ;
81600
81601   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81602   arg2 = (Dali::Actor *)jarg2;
81603   if (!arg2) {
81604     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
81605     return ;
81606   }
81607   arg3 = (float)jarg3;
81608   {
81609     try {
81610       (arg1)->ScrollTo(*arg2,arg3);
81611     } catch (std::out_of_range& e) {
81612       {
81613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81614       };
81615     } catch (std::exception& e) {
81616       {
81617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81618       };
81619     } catch (Dali::DaliException e) {
81620       {
81621         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81622       };
81623     } catch (...) {
81624       {
81625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81626       };
81627     }
81628   }
81629
81630 }
81631
81632
81633 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_ScrollToSnapPoint(void * jarg1) {
81634   unsigned int jresult ;
81635   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81636   bool result;
81637
81638   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81639   {
81640     try {
81641       result = (bool)(arg1)->ScrollToSnapPoint();
81642     } catch (std::out_of_range& e) {
81643       {
81644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81645       };
81646     } catch (std::exception& e) {
81647       {
81648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81649       };
81650     } catch (Dali::DaliException e) {
81651       {
81652         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81653       };
81654     } catch (...) {
81655       {
81656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81657       };
81658     }
81659   }
81660
81661   jresult = result;
81662   return jresult;
81663 }
81664
81665
81666 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyConstraintToChildren(void * jarg1, void * jarg2) {
81667   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81668   Dali::Constraint arg2 ;
81669   Dali::Constraint *argp2 ;
81670
81671   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81672   argp2 = (Dali::Constraint *)jarg2;
81673   if (!argp2) {
81674     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Constraint", 0);
81675     return ;
81676   }
81677   arg2 = *argp2;
81678   {
81679     try {
81680       (arg1)->ApplyConstraintToChildren(arg2);
81681     } catch (std::out_of_range& e) {
81682       {
81683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81684       };
81685     } catch (std::exception& e) {
81686       {
81687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81688       };
81689     } catch (Dali::DaliException e) {
81690       {
81691         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81692       };
81693     } catch (...) {
81694       {
81695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81696       };
81697     }
81698   }
81699
81700 }
81701
81702
81703 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveConstraintsFromChildren(void * jarg1) {
81704   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81705
81706   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81707   {
81708     try {
81709       (arg1)->RemoveConstraintsFromChildren();
81710     } catch (std::out_of_range& e) {
81711       {
81712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81713       };
81714     } catch (std::exception& e) {
81715       {
81716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81717       };
81718     } catch (Dali::DaliException e) {
81719       {
81720         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81721       };
81722     } catch (...) {
81723       {
81724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81725       };
81726     }
81727   }
81728
81729 }
81730
81731
81732 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyEffect(void * jarg1, void * jarg2) {
81733   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81734   Dali::Toolkit::ScrollViewEffect arg2 ;
81735   Dali::Toolkit::ScrollViewEffect *argp2 ;
81736
81737   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81738   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
81739   if (!argp2) {
81740     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
81741     return ;
81742   }
81743   arg2 = *argp2;
81744   {
81745     try {
81746       (arg1)->ApplyEffect(arg2);
81747     } catch (std::out_of_range& e) {
81748       {
81749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81750       };
81751     } catch (std::exception& e) {
81752       {
81753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81754       };
81755     } catch (Dali::DaliException e) {
81756       {
81757         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81758       };
81759     } catch (...) {
81760       {
81761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81762       };
81763     }
81764   }
81765
81766 }
81767
81768
81769 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveEffect(void * jarg1, void * jarg2) {
81770   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81771   Dali::Toolkit::ScrollViewEffect arg2 ;
81772   Dali::Toolkit::ScrollViewEffect *argp2 ;
81773
81774   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81775   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
81776   if (!argp2) {
81777     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
81778     return ;
81779   }
81780   arg2 = *argp2;
81781   {
81782     try {
81783       (arg1)->RemoveEffect(arg2);
81784     } catch (std::out_of_range& e) {
81785       {
81786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81787       };
81788     } catch (std::exception& e) {
81789       {
81790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81791       };
81792     } catch (Dali::DaliException e) {
81793       {
81794         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81795       };
81796     } catch (...) {
81797       {
81798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81799       };
81800     }
81801   }
81802
81803 }
81804
81805
81806 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveAllEffects(void * jarg1) {
81807   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81808
81809   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81810   {
81811     try {
81812       (arg1)->RemoveAllEffects();
81813     } catch (std::out_of_range& e) {
81814       {
81815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81816       };
81817     } catch (std::exception& e) {
81818       {
81819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81820       };
81821     } catch (Dali::DaliException e) {
81822       {
81823         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81824       };
81825     } catch (...) {
81826       {
81827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81828       };
81829     }
81830   }
81831
81832 }
81833
81834
81835 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_BindActor(void * jarg1, void * jarg2) {
81836   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81837   Dali::Actor arg2 ;
81838   Dali::Actor *argp2 ;
81839
81840   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81841   argp2 = (Dali::Actor *)jarg2;
81842   if (!argp2) {
81843     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
81844     return ;
81845   }
81846   arg2 = *argp2;
81847   {
81848     try {
81849       (arg1)->BindActor(arg2);
81850     } catch (std::out_of_range& e) {
81851       {
81852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81853       };
81854     } catch (std::exception& e) {
81855       {
81856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81857       };
81858     } catch (Dali::DaliException e) {
81859       {
81860         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81861       };
81862     } catch (...) {
81863       {
81864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81865       };
81866     }
81867   }
81868
81869 }
81870
81871
81872 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_UnbindActor(void * jarg1, void * jarg2) {
81873   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81874   Dali::Actor arg2 ;
81875   Dali::Actor *argp2 ;
81876
81877   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81878   argp2 = (Dali::Actor *)jarg2;
81879   if (!argp2) {
81880     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
81881     return ;
81882   }
81883   arg2 = *argp2;
81884   {
81885     try {
81886       (arg1)->UnbindActor(arg2);
81887     } catch (std::out_of_range& e) {
81888       {
81889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81890       };
81891     } catch (std::exception& e) {
81892       {
81893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81894       };
81895     } catch (Dali::DaliException e) {
81896       {
81897         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81898       };
81899     } catch (...) {
81900       {
81901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81902       };
81903     }
81904   }
81905
81906 }
81907
81908
81909 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
81910   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81911   Dali::Radian arg2 ;
81912   Dali::Radian arg3 ;
81913   Dali::Radian *argp2 ;
81914   Dali::Radian *argp3 ;
81915
81916   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81917   argp2 = (Dali::Radian *)jarg2;
81918   if (!argp2) {
81919     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
81920     return ;
81921   }
81922   arg2 = *argp2;
81923   argp3 = (Dali::Radian *)jarg3;
81924   if (!argp3) {
81925     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
81926     return ;
81927   }
81928   arg3 = *argp3;
81929   {
81930     try {
81931       (arg1)->SetScrollingDirection(arg2,arg3);
81932     } catch (std::out_of_range& e) {
81933       {
81934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81935       };
81936     } catch (std::exception& e) {
81937       {
81938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81939       };
81940     } catch (Dali::DaliException e) {
81941       {
81942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81943       };
81944     } catch (...) {
81945       {
81946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81947       };
81948     }
81949   }
81950
81951 }
81952
81953
81954 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_1(void * jarg1, void * jarg2) {
81955   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81956   Dali::Radian arg2 ;
81957   Dali::Radian *argp2 ;
81958
81959   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81960   argp2 = (Dali::Radian *)jarg2;
81961   if (!argp2) {
81962     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
81963     return ;
81964   }
81965   arg2 = *argp2;
81966   {
81967     try {
81968       (arg1)->SetScrollingDirection(arg2);
81969     } catch (std::out_of_range& e) {
81970       {
81971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81972       };
81973     } catch (std::exception& e) {
81974       {
81975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81976       };
81977     } catch (Dali::DaliException e) {
81978       {
81979         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81980       };
81981     } catch (...) {
81982       {
81983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81984       };
81985     }
81986   }
81987
81988 }
81989
81990
81991 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveScrollingDirection(void * jarg1, void * jarg2) {
81992   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81993   Dali::Radian arg2 ;
81994   Dali::Radian *argp2 ;
81995
81996   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81997   argp2 = (Dali::Radian *)jarg2;
81998   if (!argp2) {
81999     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
82000     return ;
82001   }
82002   arg2 = *argp2;
82003   {
82004     try {
82005       (arg1)->RemoveScrollingDirection(arg2);
82006     } catch (std::out_of_range& e) {
82007       {
82008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82009       };
82010     } catch (std::exception& e) {
82011       {
82012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82013       };
82014     } catch (Dali::DaliException e) {
82015       {
82016         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82017       };
82018     } catch (...) {
82019       {
82020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82021       };
82022     }
82023   }
82024
82025 }
82026
82027
82028 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapStartedSignal(void * jarg1) {
82029   void * jresult ;
82030   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82031   Dali::Toolkit::ScrollView::SnapStartedSignalType *result = 0 ;
82032
82033   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82034   {
82035     try {
82036       result = (Dali::Toolkit::ScrollView::SnapStartedSignalType *) &(arg1)->SnapStartedSignal();
82037     } catch (std::out_of_range& e) {
82038       {
82039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82040       };
82041     } catch (std::exception& e) {
82042       {
82043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82044       };
82045     } catch (Dali::DaliException e) {
82046       {
82047         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82048       };
82049     } catch (...) {
82050       {
82051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82052       };
82053     }
82054   }
82055
82056   jresult = (void *)result;
82057   return jresult;
82058 }
82059
82060
82061 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_ROWS_get() {
82062   int jresult ;
82063   int result;
82064
82065   result = (int)Dali::Toolkit::TableView::Property::ROWS;
82066   jresult = (int)result;
82067   return jresult;
82068 }
82069
82070
82071 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_COLUMNS_get() {
82072   int jresult ;
82073   int result;
82074
82075   result = (int)Dali::Toolkit::TableView::Property::COLUMNS;
82076   jresult = (int)result;
82077   return jresult;
82078 }
82079
82080
82081 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_CELL_PADDING_get() {
82082   int jresult ;
82083   int result;
82084
82085   result = (int)Dali::Toolkit::TableView::Property::CELL_PADDING;
82086   jresult = (int)result;
82087   return jresult;
82088 }
82089
82090
82091 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_ROWS_get() {
82092   int jresult ;
82093   int result;
82094
82095   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_ROWS;
82096   jresult = (int)result;
82097   return jresult;
82098 }
82099
82100
82101 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_COLUMNS_get() {
82102   int jresult ;
82103   int result;
82104
82105   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_COLUMNS;
82106   jresult = (int)result;
82107   return jresult;
82108 }
82109
82110
82111 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_Property() {
82112   void * jresult ;
82113   Dali::Toolkit::TableView::Property *result = 0 ;
82114
82115   {
82116     try {
82117       result = (Dali::Toolkit::TableView::Property *)new Dali::Toolkit::TableView::Property();
82118     } catch (std::out_of_range& e) {
82119       {
82120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82121       };
82122     } catch (std::exception& e) {
82123       {
82124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82125       };
82126     } catch (Dali::DaliException e) {
82127       {
82128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82129       };
82130     } catch (...) {
82131       {
82132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82133       };
82134     }
82135   }
82136
82137   jresult = (void *)result;
82138   return jresult;
82139 }
82140
82141
82142 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_Property(void * jarg1) {
82143   Dali::Toolkit::TableView::Property *arg1 = (Dali::Toolkit::TableView::Property *) 0 ;
82144
82145   arg1 = (Dali::Toolkit::TableView::Property *)jarg1;
82146   {
82147     try {
82148       delete arg1;
82149     } catch (std::out_of_range& e) {
82150       {
82151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82152       };
82153     } catch (std::exception& e) {
82154       {
82155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82156       };
82157     } catch (Dali::DaliException e) {
82158       {
82159         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82160       };
82161     } catch (...) {
82162       {
82163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82164       };
82165     }
82166   }
82167
82168 }
82169
82170
82171 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_INDEX_get() {
82172   int jresult ;
82173   int result;
82174
82175   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_INDEX;
82176   jresult = (int)result;
82177   return jresult;
82178 }
82179
82180
82181 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_ROW_SPAN_get() {
82182   int jresult ;
82183   int result;
82184
82185   result = (int)Dali::Toolkit::TableView::ChildProperty::ROW_SPAN;
82186   jresult = (int)result;
82187   return jresult;
82188 }
82189
82190
82191 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_COLUMN_SPAN_get() {
82192   int jresult ;
82193   int result;
82194
82195   result = (int)Dali::Toolkit::TableView::ChildProperty::COLUMN_SPAN;
82196   jresult = (int)result;
82197   return jresult;
82198 }
82199
82200
82201 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_HORIZONTAL_ALIGNMENT_get() {
82202   int jresult ;
82203   int result;
82204
82205   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_HORIZONTAL_ALIGNMENT;
82206   jresult = (int)result;
82207   return jresult;
82208 }
82209
82210
82211 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_VERTICAL_ALIGNMENT_get() {
82212   int jresult ;
82213   int result;
82214
82215   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_VERTICAL_ALIGNMENT;
82216   jresult = (int)result;
82217   return jresult;
82218 }
82219
82220
82221 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_ChildProperty() {
82222   void * jresult ;
82223   Dali::Toolkit::TableView::ChildProperty *result = 0 ;
82224
82225   {
82226     try {
82227       result = (Dali::Toolkit::TableView::ChildProperty *)new Dali::Toolkit::TableView::ChildProperty();
82228     } catch (std::out_of_range& e) {
82229       {
82230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82231       };
82232     } catch (std::exception& e) {
82233       {
82234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82235       };
82236     } catch (Dali::DaliException e) {
82237       {
82238         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82239       };
82240     } catch (...) {
82241       {
82242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82243       };
82244     }
82245   }
82246
82247   jresult = (void *)result;
82248   return jresult;
82249 }
82250
82251
82252 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_ChildProperty(void * jarg1) {
82253   Dali::Toolkit::TableView::ChildProperty *arg1 = (Dali::Toolkit::TableView::ChildProperty *) 0 ;
82254
82255   arg1 = (Dali::Toolkit::TableView::ChildProperty *)jarg1;
82256   {
82257     try {
82258       delete arg1;
82259     } catch (std::out_of_range& e) {
82260       {
82261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82262       };
82263     } catch (std::exception& e) {
82264       {
82265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82266       };
82267     } catch (Dali::DaliException e) {
82268       {
82269         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82270       };
82271     } catch (...) {
82272       {
82273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82274       };
82275     }
82276   }
82277
82278 }
82279
82280
82281 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_0(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4) {
82282   void * jresult ;
82283   unsigned int arg1 ;
82284   unsigned int arg2 ;
82285   unsigned int arg3 ;
82286   unsigned int arg4 ;
82287   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82288
82289   arg1 = (unsigned int)jarg1;
82290   arg2 = (unsigned int)jarg2;
82291   arg3 = (unsigned int)jarg3;
82292   arg4 = (unsigned int)jarg4;
82293   {
82294     try {
82295       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3,arg4);
82296     } catch (std::out_of_range& e) {
82297       {
82298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82299       };
82300     } catch (std::exception& e) {
82301       {
82302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82303       };
82304     } catch (Dali::DaliException e) {
82305       {
82306         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82307       };
82308     } catch (...) {
82309       {
82310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82311       };
82312     }
82313   }
82314
82315   jresult = (void *)result;
82316   return jresult;
82317 }
82318
82319
82320 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_1(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
82321   void * jresult ;
82322   unsigned int arg1 ;
82323   unsigned int arg2 ;
82324   unsigned int arg3 ;
82325   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82326
82327   arg1 = (unsigned int)jarg1;
82328   arg2 = (unsigned int)jarg2;
82329   arg3 = (unsigned int)jarg3;
82330   {
82331     try {
82332       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3);
82333     } catch (std::out_of_range& e) {
82334       {
82335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82336       };
82337     } catch (std::exception& e) {
82338       {
82339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82340       };
82341     } catch (Dali::DaliException e) {
82342       {
82343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82344       };
82345     } catch (...) {
82346       {
82347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82348       };
82349     }
82350   }
82351
82352   jresult = (void *)result;
82353   return jresult;
82354 }
82355
82356
82357 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
82358   void * jresult ;
82359   unsigned int arg1 ;
82360   unsigned int arg2 ;
82361   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82362
82363   arg1 = (unsigned int)jarg1;
82364   arg2 = (unsigned int)jarg2;
82365   {
82366     try {
82367       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2);
82368     } catch (std::out_of_range& e) {
82369       {
82370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82371       };
82372     } catch (std::exception& e) {
82373       {
82374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82375       };
82376     } catch (Dali::DaliException e) {
82377       {
82378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82379       };
82380     } catch (...) {
82381       {
82382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82383       };
82384     }
82385   }
82386
82387   jresult = (void *)result;
82388   return jresult;
82389 }
82390
82391
82392 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_3(unsigned int jarg1) {
82393   void * jresult ;
82394   unsigned int arg1 ;
82395   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82396
82397   arg1 = (unsigned int)jarg1;
82398   {
82399     try {
82400       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1);
82401     } catch (std::out_of_range& e) {
82402       {
82403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82404       };
82405     } catch (std::exception& e) {
82406       {
82407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82408       };
82409     } catch (Dali::DaliException e) {
82410       {
82411         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82412       };
82413     } catch (...) {
82414       {
82415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82416       };
82417     }
82418   }
82419
82420   jresult = (void *)result;
82421   return jresult;
82422 }
82423
82424
82425 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_4() {
82426   void * jresult ;
82427   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82428
82429   {
82430     try {
82431       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition();
82432     } catch (std::out_of_range& e) {
82433       {
82434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82435       };
82436     } catch (std::exception& e) {
82437       {
82438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82439       };
82440     } catch (Dali::DaliException e) {
82441       {
82442         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82443       };
82444     } catch (...) {
82445       {
82446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82447       };
82448     }
82449   }
82450
82451   jresult = (void *)result;
82452   return jresult;
82453 }
82454
82455
82456 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_set(void * jarg1, unsigned int jarg2) {
82457   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82458   unsigned int arg2 ;
82459
82460   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82461   arg2 = (unsigned int)jarg2;
82462   if (arg1) (arg1)->rowIndex = arg2;
82463 }
82464
82465
82466 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_get(void * jarg1) {
82467   unsigned int jresult ;
82468   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82469   unsigned int result;
82470
82471   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82472   result = (unsigned int) ((arg1)->rowIndex);
82473   jresult = result;
82474   return jresult;
82475 }
82476
82477
82478 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_set(void * jarg1, unsigned int jarg2) {
82479   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82480   unsigned int arg2 ;
82481
82482   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82483   arg2 = (unsigned int)jarg2;
82484   if (arg1) (arg1)->columnIndex = arg2;
82485 }
82486
82487
82488 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_get(void * jarg1) {
82489   unsigned int jresult ;
82490   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82491   unsigned int result;
82492
82493   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82494   result = (unsigned int) ((arg1)->columnIndex);
82495   jresult = result;
82496   return jresult;
82497 }
82498
82499
82500 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_set(void * jarg1, unsigned int jarg2) {
82501   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82502   unsigned int arg2 ;
82503
82504   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82505   arg2 = (unsigned int)jarg2;
82506   if (arg1) (arg1)->rowSpan = arg2;
82507 }
82508
82509
82510 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_get(void * jarg1) {
82511   unsigned int jresult ;
82512   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82513   unsigned int result;
82514
82515   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82516   result = (unsigned int) ((arg1)->rowSpan);
82517   jresult = result;
82518   return jresult;
82519 }
82520
82521
82522 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_set(void * jarg1, unsigned int jarg2) {
82523   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82524   unsigned int arg2 ;
82525
82526   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82527   arg2 = (unsigned int)jarg2;
82528   if (arg1) (arg1)->columnSpan = arg2;
82529 }
82530
82531
82532 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_get(void * jarg1) {
82533   unsigned int jresult ;
82534   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82535   unsigned int result;
82536
82537   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82538   result = (unsigned int) ((arg1)->columnSpan);
82539   jresult = result;
82540   return jresult;
82541 }
82542
82543
82544 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_CellPosition(void * jarg1) {
82545   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82546
82547   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82548   {
82549     try {
82550       delete arg1;
82551     } catch (std::out_of_range& e) {
82552       {
82553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82554       };
82555     } catch (std::exception& e) {
82556       {
82557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82558       };
82559     } catch (Dali::DaliException e) {
82560       {
82561         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82562       };
82563     } catch (...) {
82564       {
82565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82566       };
82567     }
82568   }
82569
82570 }
82571
82572
82573 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_0() {
82574   void * jresult ;
82575   Dali::Toolkit::TableView *result = 0 ;
82576
82577   {
82578     try {
82579       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView();
82580     } catch (std::out_of_range& e) {
82581       {
82582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82583       };
82584     } catch (std::exception& e) {
82585       {
82586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82587       };
82588     } catch (Dali::DaliException e) {
82589       {
82590         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82591       };
82592     } catch (...) {
82593       {
82594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82595       };
82596     }
82597   }
82598
82599   jresult = (void *)result;
82600   return jresult;
82601 }
82602
82603
82604 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_1(void * jarg1) {
82605   void * jresult ;
82606   Dali::Toolkit::TableView *arg1 = 0 ;
82607   Dali::Toolkit::TableView *result = 0 ;
82608
82609   arg1 = (Dali::Toolkit::TableView *)jarg1;
82610   if (!arg1) {
82611     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
82612     return 0;
82613   }
82614   {
82615     try {
82616       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView((Dali::Toolkit::TableView const &)*arg1);
82617     } catch (std::out_of_range& e) {
82618       {
82619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82620       };
82621     } catch (std::exception& e) {
82622       {
82623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82624       };
82625     } catch (Dali::DaliException e) {
82626       {
82627         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82628       };
82629     } catch (...) {
82630       {
82631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82632       };
82633     }
82634   }
82635
82636   jresult = (void *)result;
82637   return jresult;
82638 }
82639
82640
82641 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_Assign(void * jarg1, void * jarg2) {
82642   void * jresult ;
82643   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82644   Dali::Toolkit::TableView *arg2 = 0 ;
82645   Dali::Toolkit::TableView *result = 0 ;
82646
82647   arg1 = (Dali::Toolkit::TableView *)jarg1;
82648   arg2 = (Dali::Toolkit::TableView *)jarg2;
82649   if (!arg2) {
82650     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
82651     return 0;
82652   }
82653   {
82654     try {
82655       result = (Dali::Toolkit::TableView *) &(arg1)->operator =((Dali::Toolkit::TableView const &)*arg2);
82656     } catch (std::out_of_range& e) {
82657       {
82658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82659       };
82660     } catch (std::exception& e) {
82661       {
82662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82663       };
82664     } catch (Dali::DaliException e) {
82665       {
82666         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82667       };
82668     } catch (...) {
82669       {
82670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82671       };
82672     }
82673   }
82674
82675   jresult = (void *)result;
82676   return jresult;
82677 }
82678
82679
82680 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView(void * jarg1) {
82681   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82682
82683   arg1 = (Dali::Toolkit::TableView *)jarg1;
82684   {
82685     try {
82686       delete arg1;
82687     } catch (std::out_of_range& e) {
82688       {
82689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82690       };
82691     } catch (std::exception& e) {
82692       {
82693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82694       };
82695     } catch (Dali::DaliException e) {
82696       {
82697         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82698       };
82699     } catch (...) {
82700       {
82701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82702       };
82703     }
82704   }
82705
82706 }
82707
82708
82709 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_New(unsigned int jarg1, unsigned int jarg2) {
82710   void * jresult ;
82711   unsigned int arg1 ;
82712   unsigned int arg2 ;
82713   Dali::Toolkit::TableView result;
82714
82715   arg1 = (unsigned int)jarg1;
82716   arg2 = (unsigned int)jarg2;
82717   {
82718     try {
82719       result = Dali::Toolkit::TableView::New(arg1,arg2);
82720     } catch (std::out_of_range& e) {
82721       {
82722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82723       };
82724     } catch (std::exception& e) {
82725       {
82726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82727       };
82728     } catch (Dali::DaliException e) {
82729       {
82730         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82731       };
82732     } catch (...) {
82733       {
82734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82735       };
82736     }
82737   }
82738
82739   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
82740   return jresult;
82741 }
82742
82743
82744 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_DownCast(void * jarg1) {
82745   void * jresult ;
82746   Dali::BaseHandle arg1 ;
82747   Dali::BaseHandle *argp1 ;
82748   Dali::Toolkit::TableView result;
82749
82750   argp1 = (Dali::BaseHandle *)jarg1;
82751   if (!argp1) {
82752     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
82753     return 0;
82754   }
82755   arg1 = *argp1;
82756   {
82757     try {
82758       result = Dali::Toolkit::TableView::DownCast(arg1);
82759     } catch (std::out_of_range& e) {
82760       {
82761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82762       };
82763     } catch (std::exception& e) {
82764       {
82765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82766       };
82767     } catch (Dali::DaliException e) {
82768       {
82769         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82770       };
82771     } catch (...) {
82772       {
82773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82774       };
82775     }
82776   }
82777
82778   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
82779   return jresult;
82780 }
82781
82782
82783 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_AddChild(void * jarg1, void * jarg2, void * jarg3) {
82784   unsigned int jresult ;
82785   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82786   Dali::Actor arg2 ;
82787   Dali::Toolkit::TableView::CellPosition arg3 ;
82788   Dali::Actor *argp2 ;
82789   Dali::Toolkit::TableView::CellPosition *argp3 ;
82790   bool result;
82791
82792   arg1 = (Dali::Toolkit::TableView *)jarg1;
82793   argp2 = (Dali::Actor *)jarg2;
82794   if (!argp2) {
82795     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82796     return 0;
82797   }
82798   arg2 = *argp2;
82799   argp3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
82800   if (!argp3) {
82801     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
82802     return 0;
82803   }
82804   arg3 = *argp3;
82805   {
82806     try {
82807       result = (bool)(arg1)->AddChild(arg2,arg3);
82808     } catch (std::out_of_range& e) {
82809       {
82810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82811       };
82812     } catch (std::exception& e) {
82813       {
82814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82815       };
82816     } catch (Dali::DaliException e) {
82817       {
82818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82819       };
82820     } catch (...) {
82821       {
82822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82823       };
82824     }
82825   }
82826
82827   jresult = result;
82828   return jresult;
82829 }
82830
82831
82832 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetChildAt(void * jarg1, void * jarg2) {
82833   void * jresult ;
82834   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82835   Dali::Toolkit::TableView::CellPosition arg2 ;
82836   Dali::Toolkit::TableView::CellPosition *argp2 ;
82837   Dali::Actor result;
82838
82839   arg1 = (Dali::Toolkit::TableView *)jarg1;
82840   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
82841   if (!argp2) {
82842     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
82843     return 0;
82844   }
82845   arg2 = *argp2;
82846   {
82847     try {
82848       result = (arg1)->GetChildAt(arg2);
82849     } catch (std::out_of_range& e) {
82850       {
82851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82852       };
82853     } catch (std::exception& e) {
82854       {
82855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82856       };
82857     } catch (Dali::DaliException e) {
82858       {
82859         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82860       };
82861     } catch (...) {
82862       {
82863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82864       };
82865     }
82866   }
82867
82868   jresult = new Dali::Actor((const Dali::Actor &)result);
82869   return jresult;
82870 }
82871
82872
82873 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_RemoveChildAt(void * jarg1, void * jarg2) {
82874   void * jresult ;
82875   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82876   Dali::Toolkit::TableView::CellPosition arg2 ;
82877   Dali::Toolkit::TableView::CellPosition *argp2 ;
82878   Dali::Actor result;
82879
82880   arg1 = (Dali::Toolkit::TableView *)jarg1;
82881   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
82882   if (!argp2) {
82883     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
82884     return 0;
82885   }
82886   arg2 = *argp2;
82887   {
82888     try {
82889       result = (arg1)->RemoveChildAt(arg2);
82890     } catch (std::out_of_range& e) {
82891       {
82892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82893       };
82894     } catch (std::exception& e) {
82895       {
82896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82897       };
82898     } catch (Dali::DaliException e) {
82899       {
82900         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82901       };
82902     } catch (...) {
82903       {
82904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82905       };
82906     }
82907   }
82908
82909   jresult = new Dali::Actor((const Dali::Actor &)result);
82910   return jresult;
82911 }
82912
82913
82914 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_FindChildPosition(void * jarg1, void * jarg2, void * jarg3) {
82915   unsigned int jresult ;
82916   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82917   Dali::Actor arg2 ;
82918   Dali::Toolkit::TableView::CellPosition *arg3 = 0 ;
82919   Dali::Actor *argp2 ;
82920   bool result;
82921
82922   arg1 = (Dali::Toolkit::TableView *)jarg1;
82923   argp2 = (Dali::Actor *)jarg2;
82924   if (!argp2) {
82925     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82926     return 0;
82927   }
82928   arg2 = *argp2;
82929   arg3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
82930   if (!arg3) {
82931     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView::CellPosition & type is null", 0);
82932     return 0;
82933   }
82934   {
82935     try {
82936       result = (bool)(arg1)->FindChildPosition(arg2,*arg3);
82937     } catch (std::out_of_range& e) {
82938       {
82939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82940       };
82941     } catch (std::exception& e) {
82942       {
82943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82944       };
82945     } catch (Dali::DaliException e) {
82946       {
82947         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82948       };
82949     } catch (...) {
82950       {
82951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82952       };
82953     }
82954   }
82955
82956   jresult = result;
82957   return jresult;
82958 }
82959
82960
82961 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertRow(void * jarg1, unsigned int jarg2) {
82962   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82963   unsigned int arg2 ;
82964
82965   arg1 = (Dali::Toolkit::TableView *)jarg1;
82966   arg2 = (unsigned int)jarg2;
82967   {
82968     try {
82969       (arg1)->InsertRow(arg2);
82970     } catch (std::out_of_range& e) {
82971       {
82972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82973       };
82974     } catch (std::exception& e) {
82975       {
82976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82977       };
82978     } catch (Dali::DaliException e) {
82979       {
82980         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82981       };
82982     } catch (...) {
82983       {
82984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82985       };
82986     }
82987   }
82988
82989 }
82990
82991
82992 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_0(void * jarg1, unsigned int jarg2) {
82993   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82994   unsigned int arg2 ;
82995
82996   arg1 = (Dali::Toolkit::TableView *)jarg1;
82997   arg2 = (unsigned int)jarg2;
82998   {
82999     try {
83000       (arg1)->DeleteRow(arg2);
83001     } catch (std::out_of_range& e) {
83002       {
83003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83004       };
83005     } catch (std::exception& e) {
83006       {
83007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83008       };
83009     } catch (Dali::DaliException e) {
83010       {
83011         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83012       };
83013     } catch (...) {
83014       {
83015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83016       };
83017     }
83018   }
83019
83020 }
83021
83022
83023 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
83024   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83025   unsigned int arg2 ;
83026   std::vector< Dali::Actor > *arg3 = 0 ;
83027
83028   arg1 = (Dali::Toolkit::TableView *)jarg1;
83029   arg2 = (unsigned int)jarg2;
83030   arg3 = (std::vector< Dali::Actor > *)jarg3;
83031   if (!arg3) {
83032     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
83033     return ;
83034   }
83035   {
83036     try {
83037       (arg1)->DeleteRow(arg2,*arg3);
83038     } catch (std::out_of_range& e) {
83039       {
83040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83041       };
83042     } catch (std::exception& e) {
83043       {
83044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83045       };
83046     } catch (Dali::DaliException e) {
83047       {
83048         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83049       };
83050     } catch (...) {
83051       {
83052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83053       };
83054     }
83055   }
83056
83057 }
83058
83059
83060 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertColumn(void * jarg1, unsigned int jarg2) {
83061   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83062   unsigned int arg2 ;
83063
83064   arg1 = (Dali::Toolkit::TableView *)jarg1;
83065   arg2 = (unsigned int)jarg2;
83066   {
83067     try {
83068       (arg1)->InsertColumn(arg2);
83069     } catch (std::out_of_range& e) {
83070       {
83071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83072       };
83073     } catch (std::exception& e) {
83074       {
83075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83076       };
83077     } catch (Dali::DaliException e) {
83078       {
83079         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83080       };
83081     } catch (...) {
83082       {
83083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83084       };
83085     }
83086   }
83087
83088 }
83089
83090
83091 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_0(void * jarg1, unsigned int jarg2) {
83092   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83093   unsigned int arg2 ;
83094
83095   arg1 = (Dali::Toolkit::TableView *)jarg1;
83096   arg2 = (unsigned int)jarg2;
83097   {
83098     try {
83099       (arg1)->DeleteColumn(arg2);
83100     } catch (std::out_of_range& e) {
83101       {
83102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83103       };
83104     } catch (std::exception& e) {
83105       {
83106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83107       };
83108     } catch (Dali::DaliException e) {
83109       {
83110         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83111       };
83112     } catch (...) {
83113       {
83114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83115       };
83116     }
83117   }
83118
83119 }
83120
83121
83122 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
83123   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83124   unsigned int arg2 ;
83125   std::vector< Dali::Actor > *arg3 = 0 ;
83126
83127   arg1 = (Dali::Toolkit::TableView *)jarg1;
83128   arg2 = (unsigned int)jarg2;
83129   arg3 = (std::vector< Dali::Actor > *)jarg3;
83130   if (!arg3) {
83131     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
83132     return ;
83133   }
83134   {
83135     try {
83136       (arg1)->DeleteColumn(arg2,*arg3);
83137     } catch (std::out_of_range& e) {
83138       {
83139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83140       };
83141     } catch (std::exception& e) {
83142       {
83143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83144       };
83145     } catch (Dali::DaliException e) {
83146       {
83147         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83148       };
83149     } catch (...) {
83150       {
83151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83152       };
83153     }
83154   }
83155
83156 }
83157
83158
83159 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_0(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
83160   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83161   unsigned int arg2 ;
83162   unsigned int arg3 ;
83163
83164   arg1 = (Dali::Toolkit::TableView *)jarg1;
83165   arg2 = (unsigned int)jarg2;
83166   arg3 = (unsigned int)jarg3;
83167   {
83168     try {
83169       (arg1)->Resize(arg2,arg3);
83170     } catch (std::out_of_range& e) {
83171       {
83172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83173       };
83174     } catch (std::exception& e) {
83175       {
83176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83177       };
83178     } catch (Dali::DaliException e) {
83179       {
83180         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83181       };
83182     } catch (...) {
83183       {
83184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83185       };
83186     }
83187   }
83188
83189 }
83190
83191
83192 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3, void * jarg4) {
83193   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83194   unsigned int arg2 ;
83195   unsigned int arg3 ;
83196   std::vector< Dali::Actor > *arg4 = 0 ;
83197
83198   arg1 = (Dali::Toolkit::TableView *)jarg1;
83199   arg2 = (unsigned int)jarg2;
83200   arg3 = (unsigned int)jarg3;
83201   arg4 = (std::vector< Dali::Actor > *)jarg4;
83202   if (!arg4) {
83203     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
83204     return ;
83205   }
83206   {
83207     try {
83208       (arg1)->Resize(arg2,arg3,*arg4);
83209     } catch (std::out_of_range& e) {
83210       {
83211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83212       };
83213     } catch (std::exception& e) {
83214       {
83215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83216       };
83217     } catch (Dali::DaliException e) {
83218       {
83219         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83220       };
83221     } catch (...) {
83222       {
83223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83224       };
83225     }
83226   }
83227
83228 }
83229
83230
83231 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellPadding(void * jarg1, void * jarg2) {
83232   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83233   Dali::Size arg2 ;
83234   Dali::Size *argp2 ;
83235
83236   arg1 = (Dali::Toolkit::TableView *)jarg1;
83237   argp2 = (Dali::Size *)jarg2;
83238   if (!argp2) {
83239     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
83240     return ;
83241   }
83242   arg2 = *argp2;
83243   {
83244     try {
83245       (arg1)->SetCellPadding(arg2);
83246     } catch (std::out_of_range& e) {
83247       {
83248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83249       };
83250     } catch (std::exception& e) {
83251       {
83252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83253       };
83254     } catch (Dali::DaliException e) {
83255       {
83256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83257       };
83258     } catch (...) {
83259       {
83260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83261       };
83262     }
83263   }
83264
83265 }
83266
83267
83268 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetCellPadding(void * jarg1) {
83269   void * jresult ;
83270   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83271   Dali::Size result;
83272
83273   arg1 = (Dali::Toolkit::TableView *)jarg1;
83274   {
83275     try {
83276       result = (arg1)->GetCellPadding();
83277     } catch (std::out_of_range& e) {
83278       {
83279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83280       };
83281     } catch (std::exception& e) {
83282       {
83283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83284       };
83285     } catch (Dali::DaliException e) {
83286       {
83287         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83288       };
83289     } catch (...) {
83290       {
83291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83292       };
83293     }
83294   }
83295
83296   jresult = new Dali::Size((const Dali::Size &)result);
83297   return jresult;
83298 }
83299
83300
83301 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitHeight(void * jarg1, unsigned int jarg2) {
83302   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83303   unsigned int arg2 ;
83304
83305   arg1 = (Dali::Toolkit::TableView *)jarg1;
83306   arg2 = (unsigned int)jarg2;
83307   {
83308     try {
83309       (arg1)->SetFitHeight(arg2);
83310     } catch (std::out_of_range& e) {
83311       {
83312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83313       };
83314     } catch (std::exception& e) {
83315       {
83316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83317       };
83318     } catch (Dali::DaliException e) {
83319       {
83320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83321       };
83322     } catch (...) {
83323       {
83324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83325       };
83326     }
83327   }
83328
83329 }
83330
83331
83332 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitHeight(void * jarg1, unsigned int jarg2) {
83333   unsigned int jresult ;
83334   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83335   unsigned int arg2 ;
83336   bool result;
83337
83338   arg1 = (Dali::Toolkit::TableView *)jarg1;
83339   arg2 = (unsigned int)jarg2;
83340   {
83341     try {
83342       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitHeight(arg2);
83343     } catch (std::out_of_range& e) {
83344       {
83345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83346       };
83347     } catch (std::exception& e) {
83348       {
83349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83350       };
83351     } catch (Dali::DaliException e) {
83352       {
83353         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83354       };
83355     } catch (...) {
83356       {
83357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83358       };
83359     }
83360   }
83361
83362   jresult = result;
83363   return jresult;
83364 }
83365
83366
83367 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitWidth(void * jarg1, unsigned int jarg2) {
83368   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83369   unsigned int arg2 ;
83370
83371   arg1 = (Dali::Toolkit::TableView *)jarg1;
83372   arg2 = (unsigned int)jarg2;
83373   {
83374     try {
83375       (arg1)->SetFitWidth(arg2);
83376     } catch (std::out_of_range& e) {
83377       {
83378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83379       };
83380     } catch (std::exception& e) {
83381       {
83382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83383       };
83384     } catch (Dali::DaliException e) {
83385       {
83386         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83387       };
83388     } catch (...) {
83389       {
83390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83391       };
83392     }
83393   }
83394
83395 }
83396
83397
83398 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitWidth(void * jarg1, unsigned int jarg2) {
83399   unsigned int jresult ;
83400   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83401   unsigned int arg2 ;
83402   bool result;
83403
83404   arg1 = (Dali::Toolkit::TableView *)jarg1;
83405   arg2 = (unsigned int)jarg2;
83406   {
83407     try {
83408       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitWidth(arg2);
83409     } catch (std::out_of_range& e) {
83410       {
83411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83412       };
83413     } catch (std::exception& e) {
83414       {
83415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83416       };
83417     } catch (Dali::DaliException e) {
83418       {
83419         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83420       };
83421     } catch (...) {
83422       {
83423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83424       };
83425     }
83426   }
83427
83428   jresult = result;
83429   return jresult;
83430 }
83431
83432
83433 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedHeight(void * jarg1, unsigned int jarg2, float jarg3) {
83434   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83435   unsigned int arg2 ;
83436   float arg3 ;
83437
83438   arg1 = (Dali::Toolkit::TableView *)jarg1;
83439   arg2 = (unsigned int)jarg2;
83440   arg3 = (float)jarg3;
83441   {
83442     try {
83443       (arg1)->SetFixedHeight(arg2,arg3);
83444     } catch (std::out_of_range& e) {
83445       {
83446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83447       };
83448     } catch (std::exception& e) {
83449       {
83450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83451       };
83452     } catch (Dali::DaliException e) {
83453       {
83454         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83455       };
83456     } catch (...) {
83457       {
83458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83459       };
83460     }
83461   }
83462
83463 }
83464
83465
83466 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedHeight(void * jarg1, unsigned int jarg2) {
83467   float jresult ;
83468   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83469   unsigned int arg2 ;
83470   float result;
83471
83472   arg1 = (Dali::Toolkit::TableView *)jarg1;
83473   arg2 = (unsigned int)jarg2;
83474   {
83475     try {
83476       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedHeight(arg2);
83477     } catch (std::out_of_range& e) {
83478       {
83479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83480       };
83481     } catch (std::exception& e) {
83482       {
83483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83484       };
83485     } catch (Dali::DaliException e) {
83486       {
83487         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83488       };
83489     } catch (...) {
83490       {
83491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83492       };
83493     }
83494   }
83495
83496   jresult = result;
83497   return jresult;
83498 }
83499
83500
83501 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeHeight(void * jarg1, unsigned int jarg2, float jarg3) {
83502   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83503   unsigned int arg2 ;
83504   float arg3 ;
83505
83506   arg1 = (Dali::Toolkit::TableView *)jarg1;
83507   arg2 = (unsigned int)jarg2;
83508   arg3 = (float)jarg3;
83509   {
83510     try {
83511       (arg1)->SetRelativeHeight(arg2,arg3);
83512     } catch (std::out_of_range& e) {
83513       {
83514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83515       };
83516     } catch (std::exception& e) {
83517       {
83518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83519       };
83520     } catch (Dali::DaliException e) {
83521       {
83522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83523       };
83524     } catch (...) {
83525       {
83526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83527       };
83528     }
83529   }
83530
83531 }
83532
83533
83534 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeHeight(void * jarg1, unsigned int jarg2) {
83535   float jresult ;
83536   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83537   unsigned int arg2 ;
83538   float result;
83539
83540   arg1 = (Dali::Toolkit::TableView *)jarg1;
83541   arg2 = (unsigned int)jarg2;
83542   {
83543     try {
83544       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeHeight(arg2);
83545     } catch (std::out_of_range& e) {
83546       {
83547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83548       };
83549     } catch (std::exception& e) {
83550       {
83551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83552       };
83553     } catch (Dali::DaliException e) {
83554       {
83555         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83556       };
83557     } catch (...) {
83558       {
83559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83560       };
83561     }
83562   }
83563
83564   jresult = result;
83565   return jresult;
83566 }
83567
83568
83569 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedWidth(void * jarg1, unsigned int jarg2, float jarg3) {
83570   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83571   unsigned int arg2 ;
83572   float arg3 ;
83573
83574   arg1 = (Dali::Toolkit::TableView *)jarg1;
83575   arg2 = (unsigned int)jarg2;
83576   arg3 = (float)jarg3;
83577   {
83578     try {
83579       (arg1)->SetFixedWidth(arg2,arg3);
83580     } catch (std::out_of_range& e) {
83581       {
83582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83583       };
83584     } catch (std::exception& e) {
83585       {
83586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83587       };
83588     } catch (Dali::DaliException e) {
83589       {
83590         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83591       };
83592     } catch (...) {
83593       {
83594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83595       };
83596     }
83597   }
83598
83599 }
83600
83601
83602 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedWidth(void * jarg1, unsigned int jarg2) {
83603   float jresult ;
83604   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83605   unsigned int arg2 ;
83606   float result;
83607
83608   arg1 = (Dali::Toolkit::TableView *)jarg1;
83609   arg2 = (unsigned int)jarg2;
83610   {
83611     try {
83612       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedWidth(arg2);
83613     } catch (std::out_of_range& e) {
83614       {
83615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83616       };
83617     } catch (std::exception& e) {
83618       {
83619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83620       };
83621     } catch (Dali::DaliException e) {
83622       {
83623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83624       };
83625     } catch (...) {
83626       {
83627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83628       };
83629     }
83630   }
83631
83632   jresult = result;
83633   return jresult;
83634 }
83635
83636
83637 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeWidth(void * jarg1, unsigned int jarg2, float jarg3) {
83638   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83639   unsigned int arg2 ;
83640   float arg3 ;
83641
83642   arg1 = (Dali::Toolkit::TableView *)jarg1;
83643   arg2 = (unsigned int)jarg2;
83644   arg3 = (float)jarg3;
83645   {
83646     try {
83647       (arg1)->SetRelativeWidth(arg2,arg3);
83648     } catch (std::out_of_range& e) {
83649       {
83650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83651       };
83652     } catch (std::exception& e) {
83653       {
83654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83655       };
83656     } catch (Dali::DaliException e) {
83657       {
83658         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83659       };
83660     } catch (...) {
83661       {
83662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83663       };
83664     }
83665   }
83666
83667 }
83668
83669
83670 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeWidth(void * jarg1, unsigned int jarg2) {
83671   float jresult ;
83672   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83673   unsigned int arg2 ;
83674   float result;
83675
83676   arg1 = (Dali::Toolkit::TableView *)jarg1;
83677   arg2 = (unsigned int)jarg2;
83678   {
83679     try {
83680       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeWidth(arg2);
83681     } catch (std::out_of_range& e) {
83682       {
83683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83684       };
83685     } catch (std::exception& e) {
83686       {
83687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83688       };
83689     } catch (Dali::DaliException e) {
83690       {
83691         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83692       };
83693     } catch (...) {
83694       {
83695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83696       };
83697     }
83698   }
83699
83700   jresult = result;
83701   return jresult;
83702 }
83703
83704
83705 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetRows(void * jarg1) {
83706   unsigned int jresult ;
83707   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83708   unsigned int result;
83709
83710   arg1 = (Dali::Toolkit::TableView *)jarg1;
83711   {
83712     try {
83713       result = (unsigned int)(arg1)->GetRows();
83714     } catch (std::out_of_range& e) {
83715       {
83716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83717       };
83718     } catch (std::exception& e) {
83719       {
83720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83721       };
83722     } catch (Dali::DaliException e) {
83723       {
83724         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83725       };
83726     } catch (...) {
83727       {
83728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83729       };
83730     }
83731   }
83732
83733   jresult = result;
83734   return jresult;
83735 }
83736
83737
83738 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetColumns(void * jarg1) {
83739   unsigned int jresult ;
83740   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83741   unsigned int result;
83742
83743   arg1 = (Dali::Toolkit::TableView *)jarg1;
83744   {
83745     try {
83746       result = (unsigned int)(arg1)->GetColumns();
83747     } catch (std::out_of_range& e) {
83748       {
83749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83750       };
83751     } catch (std::exception& e) {
83752       {
83753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83754       };
83755     } catch (Dali::DaliException e) {
83756       {
83757         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83758       };
83759     } catch (...) {
83760       {
83761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83762       };
83763     }
83764   }
83765
83766   jresult = result;
83767   return jresult;
83768 }
83769
83770
83771 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellAlignment(void * jarg1, void * jarg2, int jarg3, int jarg4) {
83772   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83773   Dali::Toolkit::TableView::CellPosition arg2 ;
83774   Dali::HorizontalAlignment::Type arg3 ;
83775   Dali::VerticalAlignment::Type arg4 ;
83776   Dali::Toolkit::TableView::CellPosition *argp2 ;
83777
83778   arg1 = (Dali::Toolkit::TableView *)jarg1;
83779   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
83780   if (!argp2) {
83781     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
83782     return ;
83783   }
83784   arg2 = *argp2;
83785   arg3 = (Dali::HorizontalAlignment::Type)jarg3;
83786   arg4 = (Dali::VerticalAlignment::Type)jarg4;
83787   {
83788     try {
83789       (arg1)->SetCellAlignment(arg2,arg3,arg4);
83790     } catch (std::out_of_range& e) {
83791       {
83792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83793       };
83794     } catch (std::exception& e) {
83795       {
83796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83797       };
83798     } catch (Dali::DaliException e) {
83799       {
83800         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83801       };
83802     } catch (...) {
83803       {
83804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83805       };
83806     }
83807   }
83808
83809 }
83810
83811
83812 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DEFAULT_RENDERING_BACKEND_get() {
83813   unsigned int jresult ;
83814   unsigned int result;
83815
83816   result = (unsigned int)(unsigned int)Dali::Toolkit::Text::DEFAULT_RENDERING_BACKEND;
83817   jresult = result;
83818   return jresult;
83819 }
83820
83821
83822 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_RENDERING_BACKEND_get() {
83823   int jresult ;
83824   int result;
83825
83826   result = (int)Dali::Toolkit::TextLabel::Property::RENDERING_BACKEND;
83827   jresult = (int)result;
83828   return jresult;
83829 }
83830
83831
83832 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_get() {
83833   int jresult ;
83834   int result;
83835
83836   result = (int)Dali::Toolkit::TextLabel::Property::TEXT;
83837   jresult = (int)result;
83838   return jresult;
83839 }
83840
83841
83842 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_FAMILY_get() {
83843   int jresult ;
83844   int result;
83845
83846   result = (int)Dali::Toolkit::TextLabel::Property::FONT_FAMILY;
83847   jresult = (int)result;
83848   return jresult;
83849 }
83850
83851
83852 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_STYLE_get() {
83853   int jresult ;
83854   int result;
83855
83856   result = (int)Dali::Toolkit::TextLabel::Property::FONT_STYLE;
83857   jresult = (int)result;
83858   return jresult;
83859 }
83860
83861
83862 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_POINT_SIZE_get() {
83863   int jresult ;
83864   int result;
83865
83866   result = (int)Dali::Toolkit::TextLabel::Property::POINT_SIZE;
83867   jresult = (int)result;
83868   return jresult;
83869 }
83870
83871
83872 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_MULTI_LINE_get() {
83873   int jresult ;
83874   int result;
83875
83876   result = (int)Dali::Toolkit::TextLabel::Property::MULTI_LINE;
83877   jresult = (int)result;
83878   return jresult;
83879 }
83880
83881
83882 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_HORIZONTAL_ALIGNMENT_get() {
83883   int jresult ;
83884   int result;
83885
83886   result = (int)Dali::Toolkit::TextLabel::Property::HORIZONTAL_ALIGNMENT;
83887   jresult = (int)result;
83888   return jresult;
83889 }
83890
83891
83892 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_VERTICAL_ALIGNMENT_get() {
83893   int jresult ;
83894   int result;
83895
83896   result = (int)Dali::Toolkit::TextLabel::Property::VERTICAL_ALIGNMENT;
83897   jresult = (int)result;
83898   return jresult;
83899 }
83900
83901
83902 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_COLOR_get() {
83903   int jresult ;
83904   int result;
83905
83906   result = (int)Dali::Toolkit::TextLabel::Property::TEXT_COLOR;
83907   jresult = (int)result;
83908   return jresult;
83909 }
83910
83911
83912 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_MARKUP_get() {
83913   int jresult ;
83914   int result;
83915
83916   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_MARKUP;
83917   jresult = (int)result;
83918   return jresult;
83919 }
83920
83921
83922 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_AUTO_SCROLL_get() {
83923   int jresult ;
83924   int result;
83925
83926   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_AUTO_SCROLL;
83927   jresult = (int)result;
83928   return jresult;
83929 }
83930
83931
83932 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_SPEED_get() {
83933   int jresult ;
83934   int result;
83935
83936   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_SPEED;
83937   jresult = (int)result;
83938   return jresult;
83939 }
83940
83941
83942 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_LOOP_COUNT_get() {
83943   int jresult ;
83944   int result;
83945
83946   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_LOOP_COUNT;
83947   jresult = (int)result;
83948   return jresult;
83949 }
83950
83951
83952 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_GAP_get() {
83953   int jresult ;
83954   int result;
83955
83956   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_GAP;
83957   jresult = (int)result;
83958   return jresult;
83959 }
83960
83961
83962 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_LINE_SPACING_get() {
83963   int jresult ;
83964   int result;
83965
83966   result = (int)Dali::Toolkit::TextLabel::Property::LINE_SPACING;
83967   jresult = (int)result;
83968   return jresult;
83969 }
83970
83971
83972 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_get() {
83973   int jresult ;
83974   int result;
83975
83976   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE;
83977   jresult = (int)result;
83978   return jresult;
83979 }
83980
83981
83982 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_get() {
83983   int jresult ;
83984   int result;
83985
83986   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW;
83987   jresult = (int)result;
83988   return jresult;
83989 }
83990
83991
83992 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_EMBOSS_get() {
83993   int jresult ;
83994   int result;
83995
83996   result = (int)Dali::Toolkit::TextLabel::Property::EMBOSS;
83997   jresult = (int)result;
83998   return jresult;
83999 }
84000
84001
84002 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_OUTLINE_get() {
84003   int jresult ;
84004   int result;
84005
84006   result = (int)Dali::Toolkit::TextLabel::Property::OUTLINE;
84007   jresult = (int)result;
84008   return jresult;
84009 }
84010
84011
84012 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel_Property() {
84013   void * jresult ;
84014   Dali::Toolkit::TextLabel::Property *result = 0 ;
84015
84016   {
84017     try {
84018       result = (Dali::Toolkit::TextLabel::Property *)new Dali::Toolkit::TextLabel::Property();
84019     } catch (std::out_of_range& e) {
84020       {
84021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84022       };
84023     } catch (std::exception& e) {
84024       {
84025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84026       };
84027     } catch (Dali::DaliException e) {
84028       {
84029         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84030       };
84031     } catch (...) {
84032       {
84033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84034       };
84035     }
84036   }
84037
84038   jresult = (void *)result;
84039   return jresult;
84040 }
84041
84042
84043 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel_Property(void * jarg1) {
84044   Dali::Toolkit::TextLabel::Property *arg1 = (Dali::Toolkit::TextLabel::Property *) 0 ;
84045
84046   arg1 = (Dali::Toolkit::TextLabel::Property *)jarg1;
84047   {
84048     try {
84049       delete arg1;
84050     } catch (std::out_of_range& e) {
84051       {
84052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84053       };
84054     } catch (std::exception& e) {
84055       {
84056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84057       };
84058     } catch (Dali::DaliException e) {
84059       {
84060         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84061       };
84062     } catch (...) {
84063       {
84064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84065       };
84066     }
84067   }
84068
84069 }
84070
84071
84072 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_0() {
84073   void * jresult ;
84074   Dali::Toolkit::TextLabel result;
84075
84076   {
84077     try {
84078       result = Dali::Toolkit::TextLabel::New();
84079     } catch (std::out_of_range& e) {
84080       {
84081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84082       };
84083     } catch (std::exception& e) {
84084       {
84085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84086       };
84087     } catch (Dali::DaliException e) {
84088       {
84089         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84090       };
84091     } catch (...) {
84092       {
84093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84094       };
84095     }
84096   }
84097
84098   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
84099   return jresult;
84100 }
84101
84102
84103 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_1(char * jarg1) {
84104   void * jresult ;
84105   std::string *arg1 = 0 ;
84106   Dali::Toolkit::TextLabel result;
84107
84108   if (!jarg1) {
84109     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
84110     return 0;
84111   }
84112   std::string arg1_str(jarg1);
84113   arg1 = &arg1_str;
84114   {
84115     try {
84116       result = Dali::Toolkit::TextLabel::New((std::string const &)*arg1);
84117     } catch (std::out_of_range& e) {
84118       {
84119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84120       };
84121     } catch (std::exception& e) {
84122       {
84123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84124       };
84125     } catch (Dali::DaliException e) {
84126       {
84127         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84128       };
84129     } catch (...) {
84130       {
84131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84132       };
84133     }
84134   }
84135
84136   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
84137
84138   //argout typemap for const std::string&
84139
84140   return jresult;
84141 }
84142
84143
84144 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_0() {
84145   void * jresult ;
84146   Dali::Toolkit::TextLabel *result = 0 ;
84147
84148   {
84149     try {
84150       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel();
84151     } catch (std::out_of_range& e) {
84152       {
84153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84154       };
84155     } catch (std::exception& e) {
84156       {
84157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84158       };
84159     } catch (Dali::DaliException e) {
84160       {
84161         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84162       };
84163     } catch (...) {
84164       {
84165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84166       };
84167     }
84168   }
84169
84170   jresult = (void *)result;
84171   return jresult;
84172 }
84173
84174
84175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_1(void * jarg1) {
84176   void * jresult ;
84177   Dali::Toolkit::TextLabel *arg1 = 0 ;
84178   Dali::Toolkit::TextLabel *result = 0 ;
84179
84180   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
84181   if (!arg1) {
84182     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
84183     return 0;
84184   }
84185   {
84186     try {
84187       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel((Dali::Toolkit::TextLabel const &)*arg1);
84188     } catch (std::out_of_range& e) {
84189       {
84190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84191       };
84192     } catch (std::exception& e) {
84193       {
84194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84195       };
84196     } catch (Dali::DaliException e) {
84197       {
84198         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84199       };
84200     } catch (...) {
84201       {
84202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84203       };
84204     }
84205   }
84206
84207   jresult = (void *)result;
84208   return jresult;
84209 }
84210
84211
84212 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_Assign(void * jarg1, void * jarg2) {
84213   void * jresult ;
84214   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
84215   Dali::Toolkit::TextLabel *arg2 = 0 ;
84216   Dali::Toolkit::TextLabel *result = 0 ;
84217
84218   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
84219   arg2 = (Dali::Toolkit::TextLabel *)jarg2;
84220   if (!arg2) {
84221     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
84222     return 0;
84223   }
84224   {
84225     try {
84226       result = (Dali::Toolkit::TextLabel *) &(arg1)->operator =((Dali::Toolkit::TextLabel const &)*arg2);
84227     } catch (std::out_of_range& e) {
84228       {
84229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84230       };
84231     } catch (std::exception& e) {
84232       {
84233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84234       };
84235     } catch (Dali::DaliException e) {
84236       {
84237         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84238       };
84239     } catch (...) {
84240       {
84241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84242       };
84243     }
84244   }
84245
84246   jresult = (void *)result;
84247   return jresult;
84248 }
84249
84250
84251 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel(void * jarg1) {
84252   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
84253
84254   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
84255   {
84256     try {
84257       delete arg1;
84258     } catch (std::out_of_range& e) {
84259       {
84260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84261       };
84262     } catch (std::exception& e) {
84263       {
84264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84265       };
84266     } catch (Dali::DaliException e) {
84267       {
84268         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84269       };
84270     } catch (...) {
84271       {
84272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84273       };
84274     }
84275   }
84276
84277 }
84278
84279
84280 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_DownCast(void * jarg1) {
84281   void * jresult ;
84282   Dali::BaseHandle arg1 ;
84283   Dali::BaseHandle *argp1 ;
84284   Dali::Toolkit::TextLabel result;
84285
84286   argp1 = (Dali::BaseHandle *)jarg1;
84287   if (!argp1) {
84288     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
84289     return 0;
84290   }
84291   arg1 = *argp1;
84292   {
84293     try {
84294       result = Dali::Toolkit::TextLabel::DownCast(arg1);
84295     } catch (std::out_of_range& e) {
84296       {
84297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84298       };
84299     } catch (std::exception& e) {
84300       {
84301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84302       };
84303     } catch (Dali::DaliException e) {
84304       {
84305         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84306       };
84307     } catch (...) {
84308       {
84309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84310       };
84311     }
84312   }
84313
84314   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
84315   return jresult;
84316 }
84317
84318
84319 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityManager() {
84320   void * jresult ;
84321   Dali::Toolkit::AccessibilityManager *result = 0 ;
84322
84323   {
84324     try {
84325       result = (Dali::Toolkit::AccessibilityManager *)new Dali::Toolkit::AccessibilityManager();
84326     } catch (std::out_of_range& e) {
84327       {
84328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84329       };
84330     } catch (std::exception& e) {
84331       {
84332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84333       };
84334     } catch (Dali::DaliException e) {
84335       {
84336         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84337       };
84338     } catch (...) {
84339       {
84340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84341       };
84342     }
84343   }
84344
84345   jresult = (void *)result;
84346   return jresult;
84347 }
84348
84349
84350 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityManager(void * jarg1) {
84351   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84352
84353   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84354   {
84355     try {
84356       delete arg1;
84357     } catch (std::out_of_range& e) {
84358       {
84359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84360       };
84361     } catch (std::exception& e) {
84362       {
84363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84364       };
84365     } catch (Dali::DaliException e) {
84366       {
84367         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84368       };
84369     } catch (...) {
84370       {
84371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84372       };
84373     }
84374   }
84375
84376 }
84377
84378
84379 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_Get() {
84380   void * jresult ;
84381   Dali::Toolkit::AccessibilityManager result;
84382
84383   {
84384     try {
84385       result = Dali::Toolkit::AccessibilityManager::Get();
84386     } catch (std::out_of_range& e) {
84387       {
84388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84389       };
84390     } catch (std::exception& e) {
84391       {
84392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84393       };
84394     } catch (Dali::DaliException e) {
84395       {
84396         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84397       };
84398     } catch (...) {
84399       {
84400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84401       };
84402     }
84403   }
84404
84405   jresult = new Dali::Toolkit::AccessibilityManager((const Dali::Toolkit::AccessibilityManager &)result);
84406   return jresult;
84407 }
84408
84409
84410 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3, char * jarg4) {
84411   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84412   Dali::Actor arg2 ;
84413   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
84414   std::string *arg4 = 0 ;
84415   Dali::Actor *argp2 ;
84416
84417   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84418   argp2 = (Dali::Actor *)jarg2;
84419   if (!argp2) {
84420     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84421     return ;
84422   }
84423   arg2 = *argp2;
84424   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
84425   if (!jarg4) {
84426     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
84427     return ;
84428   }
84429   std::string arg4_str(jarg4);
84430   arg4 = &arg4_str;
84431   {
84432     try {
84433       (arg1)->SetAccessibilityAttribute(arg2,arg3,(std::string const &)*arg4);
84434     } catch (std::out_of_range& e) {
84435       {
84436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84437       };
84438     } catch (std::exception& e) {
84439       {
84440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84441       };
84442     } catch (Dali::DaliException e) {
84443       {
84444         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84445       };
84446     } catch (...) {
84447       {
84448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84449       };
84450     }
84451   }
84452
84453
84454   //argout typemap for const std::string&
84455
84456 }
84457
84458
84459 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3) {
84460   char * jresult ;
84461   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84462   Dali::Actor arg2 ;
84463   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
84464   Dali::Actor *argp2 ;
84465   std::string result;
84466
84467   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84468   argp2 = (Dali::Actor *)jarg2;
84469   if (!argp2) {
84470     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84471     return 0;
84472   }
84473   arg2 = *argp2;
84474   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
84475   {
84476     try {
84477       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetAccessibilityAttribute(arg2,arg3);
84478     } catch (std::out_of_range& e) {
84479       {
84480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84481       };
84482     } catch (std::exception& e) {
84483       {
84484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84485       };
84486     } catch (Dali::DaliException e) {
84487       {
84488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84489       };
84490     } catch (...) {
84491       {
84492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84493       };
84494     }
84495   }
84496
84497   jresult = SWIG_csharp_string_callback((&result)->c_str());
84498   return jresult;
84499 }
84500
84501
84502 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusOrder(void * jarg1, void * jarg2, unsigned int jarg3) {
84503   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84504   Dali::Actor arg2 ;
84505   unsigned int arg3 ;
84506   Dali::Actor *argp2 ;
84507
84508   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84509   argp2 = (Dali::Actor *)jarg2;
84510   if (!argp2) {
84511     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84512     return ;
84513   }
84514   arg2 = *argp2;
84515   arg3 = (unsigned int)jarg3;
84516   {
84517     try {
84518       (arg1)->SetFocusOrder(arg2,arg3);
84519     } catch (std::out_of_range& e) {
84520       {
84521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84522       };
84523     } catch (std::exception& e) {
84524       {
84525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84526       };
84527     } catch (Dali::DaliException e) {
84528       {
84529         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84530       };
84531     } catch (...) {
84532       {
84533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84534       };
84535     }
84536   }
84537
84538 }
84539
84540
84541 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusOrder(void * jarg1, void * jarg2) {
84542   unsigned int jresult ;
84543   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84544   Dali::Actor arg2 ;
84545   Dali::Actor *argp2 ;
84546   unsigned int result;
84547
84548   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84549   argp2 = (Dali::Actor *)jarg2;
84550   if (!argp2) {
84551     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84552     return 0;
84553   }
84554   arg2 = *argp2;
84555   {
84556     try {
84557       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetFocusOrder(arg2);
84558     } catch (std::out_of_range& e) {
84559       {
84560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84561       };
84562     } catch (std::exception& e) {
84563       {
84564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84565       };
84566     } catch (Dali::DaliException e) {
84567       {
84568         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84569       };
84570     } catch (...) {
84571       {
84572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84573       };
84574     }
84575   }
84576
84577   jresult = result;
84578   return jresult;
84579 }
84580
84581
84582 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GenerateNewFocusOrder(void * jarg1) {
84583   unsigned int jresult ;
84584   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84585   unsigned int result;
84586
84587   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84588   {
84589     try {
84590       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GenerateNewFocusOrder();
84591     } catch (std::out_of_range& e) {
84592       {
84593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84594       };
84595     } catch (std::exception& e) {
84596       {
84597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84598       };
84599     } catch (Dali::DaliException e) {
84600       {
84601         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84602       };
84603     } catch (...) {
84604       {
84605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84606       };
84607     }
84608   }
84609
84610   jresult = result;
84611   return jresult;
84612 }
84613
84614
84615 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetActorByFocusOrder(void * jarg1, unsigned int jarg2) {
84616   void * jresult ;
84617   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84618   unsigned int arg2 ;
84619   Dali::Actor result;
84620
84621   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84622   arg2 = (unsigned int)jarg2;
84623   {
84624     try {
84625       result = (arg1)->GetActorByFocusOrder(arg2);
84626     } catch (std::out_of_range& e) {
84627       {
84628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84629       };
84630     } catch (std::exception& e) {
84631       {
84632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84633       };
84634     } catch (Dali::DaliException e) {
84635       {
84636         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84637       };
84638     } catch (...) {
84639       {
84640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84641       };
84642     }
84643   }
84644
84645   jresult = new Dali::Actor((const Dali::Actor &)result);
84646   return jresult;
84647 }
84648
84649
84650 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetCurrentFocusActor(void * jarg1, void * jarg2) {
84651   unsigned int jresult ;
84652   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84653   Dali::Actor arg2 ;
84654   Dali::Actor *argp2 ;
84655   bool result;
84656
84657   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84658   argp2 = (Dali::Actor *)jarg2;
84659   if (!argp2) {
84660     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84661     return 0;
84662   }
84663   arg2 = *argp2;
84664   {
84665     try {
84666       result = (bool)(arg1)->SetCurrentFocusActor(arg2);
84667     } catch (std::out_of_range& e) {
84668       {
84669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84670       };
84671     } catch (std::exception& e) {
84672       {
84673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84674       };
84675     } catch (Dali::DaliException e) {
84676       {
84677         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84678       };
84679     } catch (...) {
84680       {
84681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84682       };
84683     }
84684   }
84685
84686   jresult = result;
84687   return jresult;
84688 }
84689
84690
84691 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusActor(void * jarg1) {
84692   void * jresult ;
84693   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84694   Dali::Actor result;
84695
84696   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84697   {
84698     try {
84699       result = (arg1)->GetCurrentFocusActor();
84700     } catch (std::out_of_range& e) {
84701       {
84702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84703       };
84704     } catch (std::exception& e) {
84705       {
84706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84707       };
84708     } catch (Dali::DaliException e) {
84709       {
84710         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84711       };
84712     } catch (...) {
84713       {
84714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84715       };
84716     }
84717   }
84718
84719   jresult = new Dali::Actor((const Dali::Actor &)result);
84720   return jresult;
84721 }
84722
84723
84724 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusGroup(void * jarg1) {
84725   void * jresult ;
84726   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84727   Dali::Actor result;
84728
84729   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84730   {
84731     try {
84732       result = (arg1)->GetCurrentFocusGroup();
84733     } catch (std::out_of_range& e) {
84734       {
84735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84736       };
84737     } catch (std::exception& e) {
84738       {
84739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84740       };
84741     } catch (Dali::DaliException e) {
84742       {
84743         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84744       };
84745     } catch (...) {
84746       {
84747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84748       };
84749     }
84750   }
84751
84752   jresult = new Dali::Actor((const Dali::Actor &)result);
84753   return jresult;
84754 }
84755
84756
84757 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusOrder(void * jarg1) {
84758   unsigned int jresult ;
84759   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84760   unsigned int result;
84761
84762   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84763   {
84764     try {
84765       result = (unsigned int)(arg1)->GetCurrentFocusOrder();
84766     } catch (std::out_of_range& e) {
84767       {
84768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84769       };
84770     } catch (std::exception& e) {
84771       {
84772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84773       };
84774     } catch (Dali::DaliException e) {
84775       {
84776         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84777       };
84778     } catch (...) {
84779       {
84780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84781       };
84782     }
84783   }
84784
84785   jresult = result;
84786   return jresult;
84787 }
84788
84789
84790 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusForward(void * jarg1) {
84791   unsigned int jresult ;
84792   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84793   bool result;
84794
84795   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84796   {
84797     try {
84798       result = (bool)(arg1)->MoveFocusForward();
84799     } catch (std::out_of_range& e) {
84800       {
84801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84802       };
84803     } catch (std::exception& e) {
84804       {
84805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84806       };
84807     } catch (Dali::DaliException e) {
84808       {
84809         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84810       };
84811     } catch (...) {
84812       {
84813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84814       };
84815     }
84816   }
84817
84818   jresult = result;
84819   return jresult;
84820 }
84821
84822
84823 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusBackward(void * jarg1) {
84824   unsigned int jresult ;
84825   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84826   bool result;
84827
84828   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84829   {
84830     try {
84831       result = (bool)(arg1)->MoveFocusBackward();
84832     } catch (std::out_of_range& e) {
84833       {
84834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84835       };
84836     } catch (std::exception& e) {
84837       {
84838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84839       };
84840     } catch (Dali::DaliException e) {
84841       {
84842         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84843       };
84844     } catch (...) {
84845       {
84846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84847       };
84848     }
84849   }
84850
84851   jresult = result;
84852   return jresult;
84853 }
84854
84855
84856 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_ClearFocus(void * jarg1) {
84857   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84858
84859   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84860   {
84861     try {
84862       (arg1)->ClearFocus();
84863     } catch (std::out_of_range& e) {
84864       {
84865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84866       };
84867     } catch (std::exception& e) {
84868       {
84869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84870       };
84871     } catch (Dali::DaliException e) {
84872       {
84873         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84874       };
84875     } catch (...) {
84876       {
84877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84878       };
84879     }
84880   }
84881
84882 }
84883
84884
84885 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_Reset(void * jarg1) {
84886   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84887
84888   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84889   {
84890     try {
84891       (arg1)->Reset();
84892     } catch (std::out_of_range& e) {
84893       {
84894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84895       };
84896     } catch (std::exception& e) {
84897       {
84898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84899       };
84900     } catch (Dali::DaliException e) {
84901       {
84902         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84903       };
84904     } catch (...) {
84905       {
84906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84907       };
84908     }
84909   }
84910
84911 }
84912
84913
84914 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusGroup(void * jarg1, void * jarg2, unsigned int jarg3) {
84915   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84916   Dali::Actor arg2 ;
84917   bool arg3 ;
84918   Dali::Actor *argp2 ;
84919
84920   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84921   argp2 = (Dali::Actor *)jarg2;
84922   if (!argp2) {
84923     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84924     return ;
84925   }
84926   arg2 = *argp2;
84927   arg3 = jarg3 ? true : false;
84928   {
84929     try {
84930       (arg1)->SetFocusGroup(arg2,arg3);
84931     } catch (std::out_of_range& e) {
84932       {
84933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84934       };
84935     } catch (std::exception& e) {
84936       {
84937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84938       };
84939     } catch (Dali::DaliException e) {
84940       {
84941         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84942       };
84943     } catch (...) {
84944       {
84945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84946       };
84947     }
84948   }
84949
84950 }
84951
84952
84953 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_IsFocusGroup(void * jarg1, void * jarg2) {
84954   unsigned int jresult ;
84955   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84956   Dali::Actor arg2 ;
84957   Dali::Actor *argp2 ;
84958   bool result;
84959
84960   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84961   argp2 = (Dali::Actor *)jarg2;
84962   if (!argp2) {
84963     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84964     return 0;
84965   }
84966   arg2 = *argp2;
84967   {
84968     try {
84969       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->IsFocusGroup(arg2);
84970     } catch (std::out_of_range& e) {
84971       {
84972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84973       };
84974     } catch (std::exception& e) {
84975       {
84976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84977       };
84978     } catch (Dali::DaliException e) {
84979       {
84980         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84981       };
84982     } catch (...) {
84983       {
84984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84985       };
84986     }
84987   }
84988
84989   jresult = result;
84990   return jresult;
84991 }
84992
84993
84994 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetGroupMode(void * jarg1, unsigned int jarg2) {
84995   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84996   bool arg2 ;
84997
84998   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84999   arg2 = jarg2 ? true : false;
85000   {
85001     try {
85002       (arg1)->SetGroupMode(arg2);
85003     } catch (std::out_of_range& e) {
85004       {
85005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85006       };
85007     } catch (std::exception& e) {
85008       {
85009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85010       };
85011     } catch (Dali::DaliException e) {
85012       {
85013         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85014       };
85015     } catch (...) {
85016       {
85017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85018       };
85019     }
85020   }
85021
85022 }
85023
85024
85025 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetGroupMode(void * jarg1) {
85026   unsigned int jresult ;
85027   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85028   bool result;
85029
85030   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85031   {
85032     try {
85033       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetGroupMode();
85034     } catch (std::out_of_range& e) {
85035       {
85036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85037       };
85038     } catch (std::exception& e) {
85039       {
85040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85041       };
85042     } catch (Dali::DaliException e) {
85043       {
85044         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85045       };
85046     } catch (...) {
85047       {
85048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85049       };
85050     }
85051   }
85052
85053   jresult = result;
85054   return jresult;
85055 }
85056
85057
85058 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetWrapMode(void * jarg1, unsigned int jarg2) {
85059   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85060   bool arg2 ;
85061
85062   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85063   arg2 = jarg2 ? true : false;
85064   {
85065     try {
85066       (arg1)->SetWrapMode(arg2);
85067     } catch (std::out_of_range& e) {
85068       {
85069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85070       };
85071     } catch (std::exception& e) {
85072       {
85073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85074       };
85075     } catch (Dali::DaliException e) {
85076       {
85077         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85078       };
85079     } catch (...) {
85080       {
85081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85082       };
85083     }
85084   }
85085
85086 }
85087
85088
85089 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetWrapMode(void * jarg1) {
85090   unsigned int jresult ;
85091   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85092   bool result;
85093
85094   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85095   {
85096     try {
85097       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetWrapMode();
85098     } catch (std::out_of_range& e) {
85099       {
85100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85101       };
85102     } catch (std::exception& e) {
85103       {
85104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85105       };
85106     } catch (Dali::DaliException e) {
85107       {
85108         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85109       };
85110     } catch (...) {
85111       {
85112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85113       };
85114     }
85115   }
85116
85117   jresult = result;
85118   return jresult;
85119 }
85120
85121
85122 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusIndicatorActor(void * jarg1, void * jarg2) {
85123   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85124   Dali::Actor arg2 ;
85125   Dali::Actor *argp2 ;
85126
85127   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85128   argp2 = (Dali::Actor *)jarg2;
85129   if (!argp2) {
85130     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85131     return ;
85132   }
85133   arg2 = *argp2;
85134   {
85135     try {
85136       (arg1)->SetFocusIndicatorActor(arg2);
85137     } catch (std::out_of_range& e) {
85138       {
85139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85140       };
85141     } catch (std::exception& e) {
85142       {
85143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85144       };
85145     } catch (Dali::DaliException e) {
85146       {
85147         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85148       };
85149     } catch (...) {
85150       {
85151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85152       };
85153     }
85154   }
85155
85156 }
85157
85158
85159 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusIndicatorActor(void * jarg1) {
85160   void * jresult ;
85161   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85162   Dali::Actor result;
85163
85164   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85165   {
85166     try {
85167       result = (arg1)->GetFocusIndicatorActor();
85168     } catch (std::out_of_range& e) {
85169       {
85170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85171       };
85172     } catch (std::exception& e) {
85173       {
85174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85175       };
85176     } catch (Dali::DaliException e) {
85177       {
85178         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85179       };
85180     } catch (...) {
85181       {
85182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85183       };
85184     }
85185   }
85186
85187   jresult = new Dali::Actor((const Dali::Actor &)result);
85188   return jresult;
85189 }
85190
85191
85192 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusGroup(void * jarg1, void * jarg2) {
85193   void * jresult ;
85194   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85195   Dali::Actor arg2 ;
85196   Dali::Actor *argp2 ;
85197   Dali::Actor result;
85198
85199   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85200   argp2 = (Dali::Actor *)jarg2;
85201   if (!argp2) {
85202     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85203     return 0;
85204   }
85205   arg2 = *argp2;
85206   {
85207     try {
85208       result = (arg1)->GetFocusGroup(arg2);
85209     } catch (std::out_of_range& e) {
85210       {
85211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85212       };
85213     } catch (std::exception& e) {
85214       {
85215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85216       };
85217     } catch (Dali::DaliException e) {
85218       {
85219         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85220       };
85221     } catch (...) {
85222       {
85223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85224       };
85225     }
85226   }
85227
85228   jresult = new Dali::Actor((const Dali::Actor &)result);
85229   return jresult;
85230 }
85231
85232
85233 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetReadPosition(void * jarg1) {
85234   void * jresult ;
85235   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85236   Dali::Vector2 result;
85237
85238   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85239   {
85240     try {
85241       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetReadPosition();
85242     } catch (std::out_of_range& e) {
85243       {
85244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85245       };
85246     } catch (std::exception& e) {
85247       {
85248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85249       };
85250     } catch (Dali::DaliException e) {
85251       {
85252         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85253       };
85254     } catch (...) {
85255       {
85256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85257       };
85258     }
85259   }
85260
85261   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
85262   return jresult;
85263 }
85264
85265
85266 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusChangedSignal(void * jarg1) {
85267   void * jresult ;
85268   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85269   Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *result = 0 ;
85270
85271   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85272   {
85273     try {
85274       result = (Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *) &(arg1)->FocusChangedSignal();
85275     } catch (std::out_of_range& e) {
85276       {
85277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85278       };
85279     } catch (std::exception& e) {
85280       {
85281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85282       };
85283     } catch (Dali::DaliException e) {
85284       {
85285         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85286       };
85287     } catch (...) {
85288       {
85289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85290       };
85291     }
85292   }
85293
85294   jresult = (void *)result;
85295   return jresult;
85296 }
85297
85298
85299 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusOvershotSignal(void * jarg1) {
85300   void * jresult ;
85301   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85302   Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *result = 0 ;
85303
85304   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85305   {
85306     try {
85307       result = (Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *) &(arg1)->FocusOvershotSignal();
85308     } catch (std::out_of_range& e) {
85309       {
85310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85311       };
85312     } catch (std::exception& e) {
85313       {
85314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85315       };
85316     } catch (Dali::DaliException e) {
85317       {
85318         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85319       };
85320     } catch (...) {
85321       {
85322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85323       };
85324     }
85325   }
85326
85327   jresult = (void *)result;
85328   return jresult;
85329 }
85330
85331
85332 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusedActorActivatedSignal(void * jarg1) {
85333   void * jresult ;
85334   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85335   Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *result = 0 ;
85336
85337   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85338   {
85339     try {
85340       result = (Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *) &(arg1)->FocusedActorActivatedSignal();
85341     } catch (std::out_of_range& e) {
85342       {
85343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85344       };
85345     } catch (std::exception& e) {
85346       {
85347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85348       };
85349     } catch (Dali::DaliException e) {
85350       {
85351         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85352       };
85353     } catch (...) {
85354       {
85355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85356       };
85357     }
85358   }
85359
85360   jresult = (void *)result;
85361   return jresult;
85362 }
85363
85364
85365 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_StatusChangedSignal(void * jarg1) {
85366   void * jresult ;
85367   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85368   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85369
85370   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85371   {
85372     try {
85373       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->StatusChangedSignal();
85374     } catch (std::out_of_range& e) {
85375       {
85376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85377       };
85378     } catch (std::exception& e) {
85379       {
85380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85381       };
85382     } catch (Dali::DaliException e) {
85383       {
85384         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85385       };
85386     } catch (...) {
85387       {
85388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85389       };
85390     }
85391   }
85392
85393   jresult = (void *)result;
85394   return jresult;
85395 }
85396
85397
85398 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionNextSignal(void * jarg1) {
85399   void * jresult ;
85400   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85401   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85402
85403   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85404   {
85405     try {
85406       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionNextSignal();
85407     } catch (std::out_of_range& e) {
85408       {
85409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85410       };
85411     } catch (std::exception& e) {
85412       {
85413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85414       };
85415     } catch (Dali::DaliException e) {
85416       {
85417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85418       };
85419     } catch (...) {
85420       {
85421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85422       };
85423     }
85424   }
85425
85426   jresult = (void *)result;
85427   return jresult;
85428 }
85429
85430
85431 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPreviousSignal(void * jarg1) {
85432   void * jresult ;
85433   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85434   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85435
85436   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85437   {
85438     try {
85439       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPreviousSignal();
85440     } catch (std::out_of_range& e) {
85441       {
85442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85443       };
85444     } catch (std::exception& e) {
85445       {
85446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85447       };
85448     } catch (Dali::DaliException e) {
85449       {
85450         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85451       };
85452     } catch (...) {
85453       {
85454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85455       };
85456     }
85457   }
85458
85459   jresult = (void *)result;
85460   return jresult;
85461 }
85462
85463
85464 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionActivateSignal(void * jarg1) {
85465   void * jresult ;
85466   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85467   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85468
85469   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85470   {
85471     try {
85472       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionActivateSignal();
85473     } catch (std::out_of_range& e) {
85474       {
85475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85476       };
85477     } catch (std::exception& e) {
85478       {
85479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85480       };
85481     } catch (Dali::DaliException e) {
85482       {
85483         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85484       };
85485     } catch (...) {
85486       {
85487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85488       };
85489     }
85490   }
85491
85492   jresult = (void *)result;
85493   return jresult;
85494 }
85495
85496
85497 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadSignal(void * jarg1) {
85498   void * jresult ;
85499   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85500   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85501
85502   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85503   {
85504     try {
85505       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadSignal();
85506     } catch (std::out_of_range& e) {
85507       {
85508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85509       };
85510     } catch (std::exception& e) {
85511       {
85512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85513       };
85514     } catch (Dali::DaliException e) {
85515       {
85516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85517       };
85518     } catch (...) {
85519       {
85520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85521       };
85522     }
85523   }
85524
85525   jresult = (void *)result;
85526   return jresult;
85527 }
85528
85529
85530 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionOverSignal(void * jarg1) {
85531   void * jresult ;
85532   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85533   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85534
85535   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85536   {
85537     try {
85538       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionOverSignal();
85539     } catch (std::out_of_range& e) {
85540       {
85541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85542       };
85543     } catch (std::exception& e) {
85544       {
85545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85546       };
85547     } catch (Dali::DaliException e) {
85548       {
85549         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85550       };
85551     } catch (...) {
85552       {
85553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85554       };
85555     }
85556   }
85557
85558   jresult = (void *)result;
85559   return jresult;
85560 }
85561
85562
85563 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadNextSignal(void * jarg1) {
85564   void * jresult ;
85565   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85566   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85567
85568   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85569   {
85570     try {
85571       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadNextSignal();
85572     } catch (std::out_of_range& e) {
85573       {
85574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85575       };
85576     } catch (std::exception& e) {
85577       {
85578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85579       };
85580     } catch (Dali::DaliException e) {
85581       {
85582         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85583       };
85584     } catch (...) {
85585       {
85586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85587       };
85588     }
85589   }
85590
85591   jresult = (void *)result;
85592   return jresult;
85593 }
85594
85595
85596 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPreviousSignal(void * jarg1) {
85597   void * jresult ;
85598   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85599   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85600
85601   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85602   {
85603     try {
85604       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPreviousSignal();
85605     } catch (std::out_of_range& e) {
85606       {
85607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85608       };
85609     } catch (std::exception& e) {
85610       {
85611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85612       };
85613     } catch (Dali::DaliException e) {
85614       {
85615         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85616       };
85617     } catch (...) {
85618       {
85619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85620       };
85621     }
85622   }
85623
85624   jresult = (void *)result;
85625   return jresult;
85626 }
85627
85628
85629 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionUpSignal(void * jarg1) {
85630   void * jresult ;
85631   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85632   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85633
85634   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85635   {
85636     try {
85637       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionUpSignal();
85638     } catch (std::out_of_range& e) {
85639       {
85640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85641       };
85642     } catch (std::exception& e) {
85643       {
85644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85645       };
85646     } catch (Dali::DaliException e) {
85647       {
85648         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85649       };
85650     } catch (...) {
85651       {
85652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85653       };
85654     }
85655   }
85656
85657   jresult = (void *)result;
85658   return jresult;
85659 }
85660
85661
85662 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionDownSignal(void * jarg1) {
85663   void * jresult ;
85664   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85665   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85666
85667   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85668   {
85669     try {
85670       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionDownSignal();
85671     } catch (std::out_of_range& e) {
85672       {
85673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85674       };
85675     } catch (std::exception& e) {
85676       {
85677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85678       };
85679     } catch (Dali::DaliException e) {
85680       {
85681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85682       };
85683     } catch (...) {
85684       {
85685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85686       };
85687     }
85688   }
85689
85690   jresult = (void *)result;
85691   return jresult;
85692 }
85693
85694
85695 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionClearFocusSignal(void * jarg1) {
85696   void * jresult ;
85697   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85698   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85699
85700   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85701   {
85702     try {
85703       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionClearFocusSignal();
85704     } catch (std::out_of_range& e) {
85705       {
85706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85707       };
85708     } catch (std::exception& e) {
85709       {
85710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85711       };
85712     } catch (Dali::DaliException e) {
85713       {
85714         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85715       };
85716     } catch (...) {
85717       {
85718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85719       };
85720     }
85721   }
85722
85723   jresult = (void *)result;
85724   return jresult;
85725 }
85726
85727
85728 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionBackSignal(void * jarg1) {
85729   void * jresult ;
85730   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85731   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85732
85733   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85734   {
85735     try {
85736       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionBackSignal();
85737     } catch (std::out_of_range& e) {
85738       {
85739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85740       };
85741     } catch (std::exception& e) {
85742       {
85743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85744       };
85745     } catch (Dali::DaliException e) {
85746       {
85747         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85748       };
85749     } catch (...) {
85750       {
85751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85752       };
85753     }
85754   }
85755
85756   jresult = (void *)result;
85757   return jresult;
85758 }
85759
85760
85761 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollUpSignal(void * jarg1) {
85762   void * jresult ;
85763   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85764   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85765
85766   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85767   {
85768     try {
85769       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollUpSignal();
85770     } catch (std::out_of_range& e) {
85771       {
85772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85773       };
85774     } catch (std::exception& e) {
85775       {
85776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85777       };
85778     } catch (Dali::DaliException e) {
85779       {
85780         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85781       };
85782     } catch (...) {
85783       {
85784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85785       };
85786     }
85787   }
85788
85789   jresult = (void *)result;
85790   return jresult;
85791 }
85792
85793
85794 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollDownSignal(void * jarg1) {
85795   void * jresult ;
85796   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85797   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85798
85799   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85800   {
85801     try {
85802       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollDownSignal();
85803     } catch (std::out_of_range& e) {
85804       {
85805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85806       };
85807     } catch (std::exception& e) {
85808       {
85809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85810       };
85811     } catch (Dali::DaliException e) {
85812       {
85813         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85814       };
85815     } catch (...) {
85816       {
85817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85818       };
85819     }
85820   }
85821
85822   jresult = (void *)result;
85823   return jresult;
85824 }
85825
85826
85827 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageLeftSignal(void * jarg1) {
85828   void * jresult ;
85829   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85830   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85831
85832   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85833   {
85834     try {
85835       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageLeftSignal();
85836     } catch (std::out_of_range& e) {
85837       {
85838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85839       };
85840     } catch (std::exception& e) {
85841       {
85842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85843       };
85844     } catch (Dali::DaliException e) {
85845       {
85846         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85847       };
85848     } catch (...) {
85849       {
85850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85851       };
85852     }
85853   }
85854
85855   jresult = (void *)result;
85856   return jresult;
85857 }
85858
85859
85860 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageRightSignal(void * jarg1) {
85861   void * jresult ;
85862   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85863   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85864
85865   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85866   {
85867     try {
85868       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageRightSignal();
85869     } catch (std::out_of_range& e) {
85870       {
85871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85872       };
85873     } catch (std::exception& e) {
85874       {
85875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85876       };
85877     } catch (Dali::DaliException e) {
85878       {
85879         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85880       };
85881     } catch (...) {
85882       {
85883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85884       };
85885     }
85886   }
85887
85888   jresult = (void *)result;
85889   return jresult;
85890 }
85891
85892
85893 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageUpSignal(void * jarg1) {
85894   void * jresult ;
85895   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85896   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85897
85898   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85899   {
85900     try {
85901       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageUpSignal();
85902     } catch (std::out_of_range& e) {
85903       {
85904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85905       };
85906     } catch (std::exception& e) {
85907       {
85908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85909       };
85910     } catch (Dali::DaliException e) {
85911       {
85912         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85913       };
85914     } catch (...) {
85915       {
85916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85917       };
85918     }
85919   }
85920
85921   jresult = (void *)result;
85922   return jresult;
85923 }
85924
85925
85926 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageDownSignal(void * jarg1) {
85927   void * jresult ;
85928   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85929   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85930
85931   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85932   {
85933     try {
85934       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageDownSignal();
85935     } catch (std::out_of_range& e) {
85936       {
85937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85938       };
85939     } catch (std::exception& e) {
85940       {
85941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85942       };
85943     } catch (Dali::DaliException e) {
85944       {
85945         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85946       };
85947     } catch (...) {
85948       {
85949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85950       };
85951     }
85952   }
85953
85954   jresult = (void *)result;
85955   return jresult;
85956 }
85957
85958
85959 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToFirstSignal(void * jarg1) {
85960   void * jresult ;
85961   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85962   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85963
85964   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85965   {
85966     try {
85967       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToFirstSignal();
85968     } catch (std::out_of_range& e) {
85969       {
85970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85971       };
85972     } catch (std::exception& e) {
85973       {
85974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85975       };
85976     } catch (Dali::DaliException e) {
85977       {
85978         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85979       };
85980     } catch (...) {
85981       {
85982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85983       };
85984     }
85985   }
85986
85987   jresult = (void *)result;
85988   return jresult;
85989 }
85990
85991
85992 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToLastSignal(void * jarg1) {
85993   void * jresult ;
85994   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85995   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85996
85997   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85998   {
85999     try {
86000       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToLastSignal();
86001     } catch (std::out_of_range& e) {
86002       {
86003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86004       };
86005     } catch (std::exception& e) {
86006       {
86007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86008       };
86009     } catch (Dali::DaliException e) {
86010       {
86011         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86012       };
86013     } catch (...) {
86014       {
86015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86016       };
86017     }
86018   }
86019
86020   jresult = (void *)result;
86021   return jresult;
86022 }
86023
86024
86025 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromTopSignal(void * jarg1) {
86026   void * jresult ;
86027   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86028   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86029
86030   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86031   {
86032     try {
86033       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromTopSignal();
86034     } catch (std::out_of_range& e) {
86035       {
86036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86037       };
86038     } catch (std::exception& e) {
86039       {
86040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86041       };
86042     } catch (Dali::DaliException e) {
86043       {
86044         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86045       };
86046     } catch (...) {
86047       {
86048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86049       };
86050     }
86051   }
86052
86053   jresult = (void *)result;
86054   return jresult;
86055 }
86056
86057
86058 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromNextSignal(void * jarg1) {
86059   void * jresult ;
86060   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86061   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86062
86063   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86064   {
86065     try {
86066       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromNextSignal();
86067     } catch (std::out_of_range& e) {
86068       {
86069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86070       };
86071     } catch (std::exception& e) {
86072       {
86073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86074       };
86075     } catch (Dali::DaliException e) {
86076       {
86077         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86078       };
86079     } catch (...) {
86080       {
86081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86082       };
86083     }
86084   }
86085
86086   jresult = (void *)result;
86087   return jresult;
86088 }
86089
86090
86091 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionZoomSignal(void * jarg1) {
86092   void * jresult ;
86093   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86094   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86095
86096   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86097   {
86098     try {
86099       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionZoomSignal();
86100     } catch (std::out_of_range& e) {
86101       {
86102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86103       };
86104     } catch (std::exception& e) {
86105       {
86106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86107       };
86108     } catch (Dali::DaliException e) {
86109       {
86110         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86111       };
86112     } catch (...) {
86113       {
86114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86115       };
86116     }
86117   }
86118
86119   jresult = (void *)result;
86120   return jresult;
86121 }
86122
86123
86124 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadIndicatorInformationSignal(void * jarg1) {
86125   void * jresult ;
86126   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86127   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86128
86129   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86130   {
86131     try {
86132       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadIndicatorInformationSignal();
86133     } catch (std::out_of_range& e) {
86134       {
86135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86136       };
86137     } catch (std::exception& e) {
86138       {
86139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86140       };
86141     } catch (Dali::DaliException e) {
86142       {
86143         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86144       };
86145     } catch (...) {
86146       {
86147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86148       };
86149     }
86150   }
86151
86152   jresult = (void *)result;
86153   return jresult;
86154 }
86155
86156
86157 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPauseResumeSignal(void * jarg1) {
86158   void * jresult ;
86159   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86160   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86161
86162   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86163   {
86164     try {
86165       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPauseResumeSignal();
86166     } catch (std::out_of_range& e) {
86167       {
86168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86169       };
86170     } catch (std::exception& e) {
86171       {
86172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86173       };
86174     } catch (Dali::DaliException e) {
86175       {
86176         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86177       };
86178     } catch (...) {
86179       {
86180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86181       };
86182     }
86183   }
86184
86185   jresult = (void *)result;
86186   return jresult;
86187 }
86188
86189
86190 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionStartStopSignal(void * jarg1) {
86191   void * jresult ;
86192   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86193   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86194
86195   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86196   {
86197     try {
86198       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionStartStopSignal();
86199     } catch (std::out_of_range& e) {
86200       {
86201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86202       };
86203     } catch (std::exception& e) {
86204       {
86205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86206       };
86207     } catch (Dali::DaliException e) {
86208       {
86209         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86210       };
86211     } catch (...) {
86212       {
86213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86214       };
86215     }
86216   }
86217
86218   jresult = (void *)result;
86219   return jresult;
86220 }
86221
86222
86223 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollSignal(void * jarg1) {
86224   void * jresult ;
86225   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86226   Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *result = 0 ;
86227
86228   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86229   {
86230     try {
86231       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *) &(arg1)->ActionScrollSignal();
86232     } catch (std::out_of_range& e) {
86233       {
86234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86235       };
86236     } catch (std::exception& e) {
86237       {
86238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86239       };
86240     } catch (Dali::DaliException e) {
86241       {
86242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86243       };
86244     } catch (...) {
86245       {
86246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86247       };
86248     }
86249   }
86250
86251   jresult = (void *)result;
86252   return jresult;
86253 }
86254
86255
86256 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleManager() {
86257   void * jresult ;
86258   Dali::Toolkit::StyleManager *result = 0 ;
86259
86260   {
86261     try {
86262       result = (Dali::Toolkit::StyleManager *)new Dali::Toolkit::StyleManager();
86263     } catch (std::out_of_range& e) {
86264       {
86265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86266       };
86267     } catch (std::exception& e) {
86268       {
86269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86270       };
86271     } catch (Dali::DaliException e) {
86272       {
86273         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86274       };
86275     } catch (...) {
86276       {
86277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86278       };
86279     }
86280   }
86281
86282   jresult = (void *)result;
86283   return jresult;
86284 }
86285
86286
86287 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleManager(void * jarg1) {
86288   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86289
86290   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86291   {
86292     try {
86293       delete arg1;
86294     } catch (std::out_of_range& e) {
86295       {
86296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86297       };
86298     } catch (std::exception& e) {
86299       {
86300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86301       };
86302     } catch (Dali::DaliException e) {
86303       {
86304         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86305       };
86306     } catch (...) {
86307       {
86308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86309       };
86310     }
86311   }
86312
86313 }
86314
86315
86316 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_Get() {
86317   void * jresult ;
86318   Dali::Toolkit::StyleManager result;
86319
86320   {
86321     try {
86322       result = Dali::Toolkit::StyleManager::Get();
86323     } catch (std::out_of_range& e) {
86324       {
86325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86326       };
86327     } catch (std::exception& e) {
86328       {
86329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86330       };
86331     } catch (Dali::DaliException e) {
86332       {
86333         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86334       };
86335     } catch (...) {
86336       {
86337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86338       };
86339     }
86340   }
86341
86342   jresult = new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)result);
86343   return jresult;
86344 }
86345
86346
86347 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyTheme(void * jarg1, char * jarg2) {
86348   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86349   std::string *arg2 = 0 ;
86350
86351   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86352   if (!jarg2) {
86353     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86354     return ;
86355   }
86356   std::string arg2_str(jarg2);
86357   arg2 = &arg2_str;
86358   {
86359     try {
86360       (arg1)->ApplyTheme((std::string const &)*arg2);
86361     } catch (std::out_of_range& e) {
86362       {
86363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86364       };
86365     } catch (std::exception& e) {
86366       {
86367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86368       };
86369     } catch (Dali::DaliException e) {
86370       {
86371         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86372       };
86373     } catch (...) {
86374       {
86375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86376       };
86377     }
86378   }
86379
86380
86381   //argout typemap for const std::string&
86382
86383 }
86384
86385
86386 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyDefaultTheme(void * jarg1) {
86387   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86388
86389   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86390   {
86391     try {
86392       (arg1)->ApplyDefaultTheme();
86393     } catch (std::out_of_range& e) {
86394       {
86395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86396       };
86397     } catch (std::exception& e) {
86398       {
86399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86400       };
86401     } catch (Dali::DaliException e) {
86402       {
86403         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86404       };
86405     } catch (...) {
86406       {
86407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86408       };
86409     }
86410   }
86411
86412 }
86413
86414
86415 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_SetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
86416   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86417   std::string *arg2 = 0 ;
86418   Dali::Property::Value *arg3 = 0 ;
86419
86420   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86421   if (!jarg2) {
86422     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86423     return ;
86424   }
86425   std::string arg2_str(jarg2);
86426   arg2 = &arg2_str;
86427   arg3 = (Dali::Property::Value *)jarg3;
86428   if (!arg3) {
86429     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
86430     return ;
86431   }
86432   {
86433     try {
86434       (arg1)->SetStyleConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
86435     } catch (std::out_of_range& e) {
86436       {
86437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86438       };
86439     } catch (std::exception& e) {
86440       {
86441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86442       };
86443     } catch (Dali::DaliException e) {
86444       {
86445         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86446       };
86447     } catch (...) {
86448       {
86449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86450       };
86451     }
86452   }
86453
86454
86455   //argout typemap for const std::string&
86456
86457 }
86458
86459
86460 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleManager_GetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
86461   unsigned int jresult ;
86462   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86463   std::string *arg2 = 0 ;
86464   Dali::Property::Value *arg3 = 0 ;
86465   bool result;
86466
86467   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86468   if (!jarg2) {
86469     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86470     return 0;
86471   }
86472   std::string arg2_str(jarg2);
86473   arg2 = &arg2_str;
86474   arg3 = (Dali::Property::Value *)jarg3;
86475   if (!arg3) {
86476     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value & type is null", 0);
86477     return 0;
86478   }
86479   {
86480     try {
86481       result = (bool)(arg1)->GetStyleConstant((std::string const &)*arg2,*arg3);
86482     } catch (std::out_of_range& e) {
86483       {
86484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86485       };
86486     } catch (std::exception& e) {
86487       {
86488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86489       };
86490     } catch (Dali::DaliException e) {
86491       {
86492         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86493       };
86494     } catch (...) {
86495       {
86496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86497       };
86498     }
86499   }
86500
86501   jresult = result;
86502
86503   //argout typemap for const std::string&
86504
86505   return jresult;
86506 }
86507
86508
86509 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyStyle(void * jarg1, void * jarg2, char * jarg3, char * jarg4) {
86510   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86511   Dali::Toolkit::Control arg2 ;
86512   std::string *arg3 = 0 ;
86513   std::string *arg4 = 0 ;
86514   Dali::Toolkit::Control *argp2 ;
86515
86516   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86517   argp2 = (Dali::Toolkit::Control *)jarg2;
86518   if (!argp2) {
86519     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
86520     return ;
86521   }
86522   arg2 = *argp2;
86523   if (!jarg3) {
86524     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86525     return ;
86526   }
86527   std::string arg3_str(jarg3);
86528   arg3 = &arg3_str;
86529   if (!jarg4) {
86530     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86531     return ;
86532   }
86533   std::string arg4_str(jarg4);
86534   arg4 = &arg4_str;
86535   {
86536     try {
86537       (arg1)->ApplyStyle(arg2,(std::string const &)*arg3,(std::string const &)*arg4);
86538     } catch (std::out_of_range& e) {
86539       {
86540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86541       };
86542     } catch (std::exception& e) {
86543       {
86544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86545       };
86546     } catch (Dali::DaliException e) {
86547       {
86548         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86549       };
86550     } catch (...) {
86551       {
86552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86553       };
86554     }
86555   }
86556
86557
86558   //argout typemap for const std::string&
86559
86560
86561   //argout typemap for const std::string&
86562
86563 }
86564
86565
86566 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_StyleChangedSignal(void * jarg1) {
86567   void * jresult ;
86568   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86569   Dali::Toolkit::StyleManager::StyleChangedSignalType *result = 0 ;
86570
86571   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86572   {
86573     try {
86574       result = (Dali::Toolkit::StyleManager::StyleChangedSignalType *) &(arg1)->StyleChangedSignal();
86575     } catch (std::out_of_range& e) {
86576       {
86577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86578       };
86579     } catch (std::exception& e) {
86580       {
86581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86582       };
86583     } catch (Dali::DaliException e) {
86584       {
86585         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86586       };
86587     } catch (...) {
86588       {
86589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86590       };
86591     }
86592   }
86593
86594   jresult = (void *)result;
86595   return jresult;
86596 }
86597
86598
86599 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_LOWER_BOUND_get() {
86600   int jresult ;
86601   int result;
86602
86603   result = (int)Dali::Toolkit::Slider::Property::LOWER_BOUND;
86604   jresult = (int)result;
86605   return jresult;
86606 }
86607
86608
86609 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_UPPER_BOUND_get() {
86610   int jresult ;
86611   int result;
86612
86613   result = (int)Dali::Toolkit::Slider::Property::UPPER_BOUND;
86614   jresult = (int)result;
86615   return jresult;
86616 }
86617
86618
86619 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_get() {
86620   int jresult ;
86621   int result;
86622
86623   result = (int)Dali::Toolkit::Slider::Property::VALUE;
86624   jresult = (int)result;
86625   return jresult;
86626 }
86627
86628
86629 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_TRACK_VISUAL_get() {
86630   int jresult ;
86631   int result;
86632
86633   result = (int)Dali::Toolkit::Slider::Property::TRACK_VISUAL;
86634   jresult = (int)result;
86635   return jresult;
86636 }
86637
86638
86639 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_HANDLE_VISUAL_get() {
86640   int jresult ;
86641   int result;
86642
86643   result = (int)Dali::Toolkit::Slider::Property::HANDLE_VISUAL;
86644   jresult = (int)result;
86645   return jresult;
86646 }
86647
86648
86649 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_PROGRESS_VISUAL_get() {
86650   int jresult ;
86651   int result;
86652
86653   result = (int)Dali::Toolkit::Slider::Property::PROGRESS_VISUAL;
86654   jresult = (int)result;
86655   return jresult;
86656 }
86657
86658
86659 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_VISUAL_get() {
86660   int jresult ;
86661   int result;
86662
86663   result = (int)Dali::Toolkit::Slider::Property::POPUP_VISUAL;
86664   jresult = (int)result;
86665   return jresult;
86666 }
86667
86668
86669 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_ARROW_VISUAL_get() {
86670   int jresult ;
86671   int result;
86672
86673   result = (int)Dali::Toolkit::Slider::Property::POPUP_ARROW_VISUAL;
86674   jresult = (int)result;
86675   return jresult;
86676 }
86677
86678
86679 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_DISABLED_COLOR_get() {
86680   int jresult ;
86681   int result;
86682
86683   result = (int)Dali::Toolkit::Slider::Property::DISABLED_COLOR;
86684   jresult = (int)result;
86685   return jresult;
86686 }
86687
86688
86689 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_PRECISION_get() {
86690   int jresult ;
86691   int result;
86692
86693   result = (int)Dali::Toolkit::Slider::Property::VALUE_PRECISION;
86694   jresult = (int)result;
86695   return jresult;
86696 }
86697
86698
86699 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_POPUP_get() {
86700   int jresult ;
86701   int result;
86702
86703   result = (int)Dali::Toolkit::Slider::Property::SHOW_POPUP;
86704   jresult = (int)result;
86705   return jresult;
86706 }
86707
86708
86709 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_VALUE_get() {
86710   int jresult ;
86711   int result;
86712
86713   result = (int)Dali::Toolkit::Slider::Property::SHOW_VALUE;
86714   jresult = (int)result;
86715   return jresult;
86716 }
86717
86718
86719 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARKS_get() {
86720   int jresult ;
86721   int result;
86722
86723   result = (int)Dali::Toolkit::Slider::Property::MARKS;
86724   jresult = (int)result;
86725   return jresult;
86726 }
86727
86728
86729 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SNAP_TO_MARKS_get() {
86730   int jresult ;
86731   int result;
86732
86733   result = (int)Dali::Toolkit::Slider::Property::SNAP_TO_MARKS;
86734   jresult = (int)result;
86735   return jresult;
86736 }
86737
86738
86739 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARK_TOLERANCE_get() {
86740   int jresult ;
86741   int result;
86742
86743   result = (int)Dali::Toolkit::Slider::Property::MARK_TOLERANCE;
86744   jresult = (int)result;
86745   return jresult;
86746 }
86747
86748
86749 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider_Property() {
86750   void * jresult ;
86751   Dali::Toolkit::Slider::Property *result = 0 ;
86752
86753   {
86754     try {
86755       result = (Dali::Toolkit::Slider::Property *)new Dali::Toolkit::Slider::Property();
86756     } catch (std::out_of_range& e) {
86757       {
86758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86759       };
86760     } catch (std::exception& e) {
86761       {
86762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86763       };
86764     } catch (Dali::DaliException e) {
86765       {
86766         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86767       };
86768     } catch (...) {
86769       {
86770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86771       };
86772     }
86773   }
86774
86775   jresult = (void *)result;
86776   return jresult;
86777 }
86778
86779
86780 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider_Property(void * jarg1) {
86781   Dali::Toolkit::Slider::Property *arg1 = (Dali::Toolkit::Slider::Property *) 0 ;
86782
86783   arg1 = (Dali::Toolkit::Slider::Property *)jarg1;
86784   {
86785     try {
86786       delete arg1;
86787     } catch (std::out_of_range& e) {
86788       {
86789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86790       };
86791     } catch (std::exception& e) {
86792       {
86793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86794       };
86795     } catch (Dali::DaliException e) {
86796       {
86797         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86798       };
86799     } catch (...) {
86800       {
86801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86802       };
86803     }
86804   }
86805
86806 }
86807
86808
86809 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_New() {
86810   void * jresult ;
86811   Dali::Toolkit::Slider result;
86812
86813   {
86814     try {
86815       result = Dali::Toolkit::Slider::New();
86816     } catch (std::out_of_range& e) {
86817       {
86818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86819       };
86820     } catch (std::exception& e) {
86821       {
86822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86823       };
86824     } catch (Dali::DaliException e) {
86825       {
86826         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86827       };
86828     } catch (...) {
86829       {
86830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86831       };
86832     }
86833   }
86834
86835   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
86836   return jresult;
86837 }
86838
86839
86840 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_0() {
86841   void * jresult ;
86842   Dali::Toolkit::Slider *result = 0 ;
86843
86844   {
86845     try {
86846       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider();
86847     } catch (std::out_of_range& e) {
86848       {
86849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86850       };
86851     } catch (std::exception& e) {
86852       {
86853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86854       };
86855     } catch (Dali::DaliException e) {
86856       {
86857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86858       };
86859     } catch (...) {
86860       {
86861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86862       };
86863     }
86864   }
86865
86866   jresult = (void *)result;
86867   return jresult;
86868 }
86869
86870
86871 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_1(void * jarg1) {
86872   void * jresult ;
86873   Dali::Toolkit::Slider *arg1 = 0 ;
86874   Dali::Toolkit::Slider *result = 0 ;
86875
86876   arg1 = (Dali::Toolkit::Slider *)jarg1;
86877   if (!arg1) {
86878     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
86879     return 0;
86880   }
86881   {
86882     try {
86883       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider((Dali::Toolkit::Slider const &)*arg1);
86884     } catch (std::out_of_range& e) {
86885       {
86886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86887       };
86888     } catch (std::exception& e) {
86889       {
86890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86891       };
86892     } catch (Dali::DaliException e) {
86893       {
86894         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86895       };
86896     } catch (...) {
86897       {
86898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86899       };
86900     }
86901   }
86902
86903   jresult = (void *)result;
86904   return jresult;
86905 }
86906
86907
86908 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_Assign(void * jarg1, void * jarg2) {
86909   void * jresult ;
86910   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
86911   Dali::Toolkit::Slider *arg2 = 0 ;
86912   Dali::Toolkit::Slider *result = 0 ;
86913
86914   arg1 = (Dali::Toolkit::Slider *)jarg1;
86915   arg2 = (Dali::Toolkit::Slider *)jarg2;
86916   if (!arg2) {
86917     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
86918     return 0;
86919   }
86920   {
86921     try {
86922       result = (Dali::Toolkit::Slider *) &(arg1)->operator =((Dali::Toolkit::Slider const &)*arg2);
86923     } catch (std::out_of_range& e) {
86924       {
86925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86926       };
86927     } catch (std::exception& e) {
86928       {
86929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86930       };
86931     } catch (Dali::DaliException e) {
86932       {
86933         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86934       };
86935     } catch (...) {
86936       {
86937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86938       };
86939     }
86940   }
86941
86942   jresult = (void *)result;
86943   return jresult;
86944 }
86945
86946
86947 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider(void * jarg1) {
86948   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
86949
86950   arg1 = (Dali::Toolkit::Slider *)jarg1;
86951   {
86952     try {
86953       delete arg1;
86954     } catch (std::out_of_range& e) {
86955       {
86956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86957       };
86958     } catch (std::exception& e) {
86959       {
86960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86961       };
86962     } catch (Dali::DaliException e) {
86963       {
86964         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86965       };
86966     } catch (...) {
86967       {
86968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86969       };
86970     }
86971   }
86972
86973 }
86974
86975
86976 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_DownCast(void * jarg1) {
86977   void * jresult ;
86978   Dali::BaseHandle arg1 ;
86979   Dali::BaseHandle *argp1 ;
86980   Dali::Toolkit::Slider result;
86981
86982   argp1 = (Dali::BaseHandle *)jarg1;
86983   if (!argp1) {
86984     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
86985     return 0;
86986   }
86987   arg1 = *argp1;
86988   {
86989     try {
86990       result = Dali::Toolkit::Slider::DownCast(arg1);
86991     } catch (std::out_of_range& e) {
86992       {
86993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86994       };
86995     } catch (std::exception& e) {
86996       {
86997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86998       };
86999     } catch (Dali::DaliException e) {
87000       {
87001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87002       };
87003     } catch (...) {
87004       {
87005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87006       };
87007     }
87008   }
87009
87010   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
87011   return jresult;
87012 }
87013
87014
87015 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_ValueChangedSignal(void * jarg1) {
87016   void * jresult ;
87017   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
87018   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
87019
87020   arg1 = (Dali::Toolkit::Slider *)jarg1;
87021   {
87022     try {
87023       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
87024     } catch (std::out_of_range& e) {
87025       {
87026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87027       };
87028     } catch (std::exception& e) {
87029       {
87030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87031       };
87032     } catch (Dali::DaliException e) {
87033       {
87034         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87035       };
87036     } catch (...) {
87037       {
87038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87039       };
87040     }
87041   }
87042
87043   jresult = (void *)result;
87044   return jresult;
87045 }
87046
87047
87048 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_SlidingFinishedSignal(void * jarg1) {
87049   void * jresult ;
87050   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
87051   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
87052
87053   arg1 = (Dali::Toolkit::Slider *)jarg1;
87054   {
87055     try {
87056       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->SlidingFinishedSignal();
87057     } catch (std::out_of_range& e) {
87058       {
87059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87060       };
87061     } catch (std::exception& e) {
87062       {
87063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87064       };
87065     } catch (Dali::DaliException e) {
87066       {
87067         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87068       };
87069     } catch (...) {
87070       {
87071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87072       };
87073     }
87074   }
87075
87076   jresult = (void *)result;
87077   return jresult;
87078 }
87079
87080
87081 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_MarkReachedSignal(void * jarg1) {
87082   void * jresult ;
87083   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
87084   Dali::Toolkit::Slider::MarkReachedSignalType *result = 0 ;
87085
87086   arg1 = (Dali::Toolkit::Slider *)jarg1;
87087   {
87088     try {
87089       result = (Dali::Toolkit::Slider::MarkReachedSignalType *) &(arg1)->MarkReachedSignal();
87090     } catch (std::out_of_range& e) {
87091       {
87092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87093       };
87094     } catch (std::exception& e) {
87095       {
87096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87097       };
87098     } catch (Dali::DaliException e) {
87099       {
87100         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87101       };
87102     } catch (...) {
87103       {
87104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87105       };
87106     }
87107   }
87108
87109   jresult = (void *)result;
87110   return jresult;
87111 }
87112
87113
87114 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VIDEO_get() {
87115   int jresult ;
87116   int result;
87117
87118   result = (int)Dali::Toolkit::VideoView::Property::VIDEO;
87119   jresult = (int)result;
87120   return jresult;
87121 }
87122
87123
87124 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_LOOPING_get() {
87125   int jresult ;
87126   int result;
87127
87128   result = (int)Dali::Toolkit::VideoView::Property::LOOPING;
87129   jresult = (int)result;
87130   return jresult;
87131 }
87132
87133
87134 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_MUTED_get() {
87135   int jresult ;
87136   int result;
87137
87138   result = (int)Dali::Toolkit::VideoView::Property::MUTED;
87139   jresult = (int)result;
87140   return jresult;
87141 }
87142
87143
87144 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VOLUME_get() {
87145   int jresult ;
87146   int result;
87147
87148   result = (int)Dali::Toolkit::VideoView::Property::VOLUME;
87149   jresult = (int)result;
87150   return jresult;
87151 }
87152
87153
87154 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_UNDERLAY_get() {
87155   int result;
87156
87157   result = (int)Dali::Toolkit::VideoView::Property::UNDERLAY;
87158
87159   return result;
87160 }
87161
87162
87163 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView_Property() {
87164   void * jresult ;
87165   Dali::Toolkit::VideoView::Property *result = 0 ;
87166
87167   {
87168     try {
87169       result = (Dali::Toolkit::VideoView::Property *)new Dali::Toolkit::VideoView::Property();
87170     } catch (std::out_of_range& e) {
87171       {
87172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87173       };
87174     } catch (std::exception& e) {
87175       {
87176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87177       };
87178     } catch (Dali::DaliException e) {
87179       {
87180         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87181       };
87182     } catch (...) {
87183       {
87184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87185       };
87186     }
87187   }
87188
87189   jresult = (void *)result;
87190   return jresult;
87191 }
87192
87193
87194 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView_Property(void * jarg1) {
87195   Dali::Toolkit::VideoView::Property *arg1 = (Dali::Toolkit::VideoView::Property *) 0 ;
87196
87197   arg1 = (Dali::Toolkit::VideoView::Property *)jarg1;
87198   {
87199     try {
87200       delete arg1;
87201     } catch (std::out_of_range& e) {
87202       {
87203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87204       };
87205     } catch (std::exception& e) {
87206       {
87207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87208       };
87209     } catch (Dali::DaliException e) {
87210       {
87211         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87212       };
87213     } catch (...) {
87214       {
87215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87216       };
87217     }
87218   }
87219
87220 }
87221
87222
87223 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_0() {
87224   void * jresult ;
87225   Dali::Toolkit::VideoView result;
87226
87227   {
87228     try {
87229       result = Dali::Toolkit::VideoView::New();
87230     } catch (std::out_of_range& e) {
87231       {
87232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87233       };
87234     } catch (std::exception& e) {
87235       {
87236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87237       };
87238     } catch (Dali::DaliException e) {
87239       {
87240         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87241       };
87242     } catch (...) {
87243       {
87244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87245       };
87246     }
87247   }
87248
87249   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
87250   return jresult;
87251 }
87252
87253
87254 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_1(char * jarg1) {
87255   void * jresult ;
87256   std::string *arg1 = 0 ;
87257   Dali::Toolkit::VideoView result;
87258
87259   if (!jarg1) {
87260     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
87261     return 0;
87262   }
87263   std::string arg1_str(jarg1);
87264   arg1 = &arg1_str;
87265   {
87266     try {
87267       result = Dali::Toolkit::VideoView::New((std::string const &)*arg1);
87268     } catch (std::out_of_range& e) {
87269       {
87270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87271       };
87272     } catch (std::exception& e) {
87273       {
87274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87275       };
87276     } catch (Dali::DaliException e) {
87277       {
87278         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87279       };
87280     } catch (...) {
87281       {
87282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87283       };
87284     }
87285   }
87286
87287   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
87288
87289   //argout typemap for const std::string&
87290
87291   return jresult;
87292 }
87293
87294
87295 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_0() {
87296   void * jresult ;
87297   Dali::Toolkit::VideoView *result = 0 ;
87298
87299   {
87300     try {
87301       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView();
87302     } catch (std::out_of_range& e) {
87303       {
87304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87305       };
87306     } catch (std::exception& e) {
87307       {
87308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87309       };
87310     } catch (Dali::DaliException e) {
87311       {
87312         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87313       };
87314     } catch (...) {
87315       {
87316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87317       };
87318     }
87319   }
87320
87321   jresult = (void *)result;
87322   return jresult;
87323 }
87324
87325
87326 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView(void * jarg1) {
87327   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87328
87329   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87330   {
87331     try {
87332       delete arg1;
87333     } catch (std::out_of_range& e) {
87334       {
87335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87336       };
87337     } catch (std::exception& e) {
87338       {
87339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87340       };
87341     } catch (Dali::DaliException e) {
87342       {
87343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87344       };
87345     } catch (...) {
87346       {
87347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87348       };
87349     }
87350   }
87351
87352 }
87353
87354
87355 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_1(void * jarg1) {
87356   void * jresult ;
87357   Dali::Toolkit::VideoView *arg1 = 0 ;
87358   Dali::Toolkit::VideoView *result = 0 ;
87359
87360   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87361   if (!arg1) {
87362     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
87363     return 0;
87364   }
87365   {
87366     try {
87367       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView((Dali::Toolkit::VideoView const &)*arg1);
87368     } catch (std::out_of_range& e) {
87369       {
87370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87371       };
87372     } catch (std::exception& e) {
87373       {
87374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87375       };
87376     } catch (Dali::DaliException e) {
87377       {
87378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87379       };
87380     } catch (...) {
87381       {
87382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87383       };
87384     }
87385   }
87386
87387   jresult = (void *)result;
87388   return jresult;
87389 }
87390
87391
87392 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_Assign(void * jarg1, void * jarg2) {
87393   void * jresult ;
87394   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87395   Dali::Toolkit::VideoView *arg2 = 0 ;
87396   Dali::Toolkit::VideoView *result = 0 ;
87397
87398   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87399   arg2 = (Dali::Toolkit::VideoView *)jarg2;
87400   if (!arg2) {
87401     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
87402     return 0;
87403   }
87404   {
87405     try {
87406       result = (Dali::Toolkit::VideoView *) &(arg1)->operator =((Dali::Toolkit::VideoView const &)*arg2);
87407     } catch (std::out_of_range& e) {
87408       {
87409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87410       };
87411     } catch (std::exception& e) {
87412       {
87413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87414       };
87415     } catch (Dali::DaliException e) {
87416       {
87417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87418       };
87419     } catch (...) {
87420       {
87421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87422       };
87423     }
87424   }
87425
87426   jresult = (void *)result;
87427   return jresult;
87428 }
87429
87430
87431 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_DownCast(void * jarg1) {
87432   void * jresult ;
87433   Dali::BaseHandle arg1 ;
87434   Dali::BaseHandle *argp1 ;
87435   Dali::Toolkit::VideoView result;
87436
87437   argp1 = (Dali::BaseHandle *)jarg1;
87438   if (!argp1) {
87439     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
87440     return 0;
87441   }
87442   arg1 = *argp1;
87443   {
87444     try {
87445       result = Dali::Toolkit::VideoView::DownCast(arg1);
87446     } catch (std::out_of_range& e) {
87447       {
87448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87449       };
87450     } catch (std::exception& e) {
87451       {
87452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87453       };
87454     } catch (Dali::DaliException e) {
87455       {
87456         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87457       };
87458     } catch (...) {
87459       {
87460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87461       };
87462     }
87463   }
87464
87465   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
87466   return jresult;
87467 }
87468
87469
87470 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Play(void * jarg1) {
87471   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87472
87473   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87474   {
87475     try {
87476       (arg1)->Play();
87477     } catch (std::out_of_range& e) {
87478       {
87479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87480       };
87481     } catch (std::exception& e) {
87482       {
87483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87484       };
87485     } catch (Dali::DaliException e) {
87486       {
87487         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87488       };
87489     } catch (...) {
87490       {
87491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87492       };
87493     }
87494   }
87495
87496 }
87497
87498
87499 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Pause(void * jarg1) {
87500   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87501
87502   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87503   {
87504     try {
87505       (arg1)->Pause();
87506     } catch (std::out_of_range& e) {
87507       {
87508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87509       };
87510     } catch (std::exception& e) {
87511       {
87512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87513       };
87514     } catch (Dali::DaliException e) {
87515       {
87516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87517       };
87518     } catch (...) {
87519       {
87520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87521       };
87522     }
87523   }
87524
87525 }
87526
87527
87528 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Stop(void * jarg1) {
87529   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87530
87531   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87532   {
87533     try {
87534       (arg1)->Stop();
87535     } catch (std::out_of_range& e) {
87536       {
87537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87538       };
87539     } catch (std::exception& e) {
87540       {
87541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87542       };
87543     } catch (Dali::DaliException e) {
87544       {
87545         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87546       };
87547     } catch (...) {
87548       {
87549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87550       };
87551     }
87552   }
87553
87554 }
87555
87556
87557 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Forward(void * jarg1, int jarg2) {
87558   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87559   int arg2 ;
87560
87561   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87562   arg2 = (int)jarg2;
87563   {
87564     try {
87565       (arg1)->Forward(arg2);
87566     } catch (std::out_of_range& e) {
87567       {
87568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87569       };
87570     } catch (std::exception& e) {
87571       {
87572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87573       };
87574     } catch (Dali::DaliException e) {
87575       {
87576         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87577       };
87578     } catch (...) {
87579       {
87580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87581       };
87582     }
87583   }
87584
87585 }
87586
87587
87588 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Backward(void * jarg1, int jarg2) {
87589   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87590   int arg2 ;
87591
87592   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87593   arg2 = (int)jarg2;
87594   {
87595     try {
87596       (arg1)->Backward(arg2);
87597     } catch (std::out_of_range& e) {
87598       {
87599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87600       };
87601     } catch (std::exception& e) {
87602       {
87603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87604       };
87605     } catch (Dali::DaliException e) {
87606       {
87607         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87608       };
87609     } catch (...) {
87610       {
87611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87612       };
87613     }
87614   }
87615
87616 }
87617
87618
87619 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_FinishedSignal(void * jarg1) {
87620   void * jresult ;
87621   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87622   Dali::Toolkit::VideoView::VideoViewSignalType *result = 0 ;
87623
87624   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87625   {
87626     try {
87627       result = (Dali::Toolkit::VideoView::VideoViewSignalType *) &(arg1)->FinishedSignal();
87628     } catch (std::out_of_range& e) {
87629       {
87630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87631       };
87632     } catch (std::exception& e) {
87633       {
87634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87635       };
87636     } catch (Dali::DaliException e) {
87637       {
87638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87639       };
87640     } catch (...) {
87641       {
87642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87643       };
87644     }
87645   }
87646
87647   jresult = (void *)result;
87648   return jresult;
87649 }
87650
87651
87652 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TITLE_get() {
87653   int jresult ;
87654   int result;
87655
87656   result = (int)Dali::Toolkit::Popup::Property::TITLE;
87657   jresult = (int)result;
87658   return jresult;
87659 }
87660
87661
87662 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTENT_get() {
87663   int jresult ;
87664   int result;
87665
87666   result = (int)Dali::Toolkit::Popup::Property::CONTENT;
87667   jresult = (int)result;
87668   return jresult;
87669 }
87670
87671
87672 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_FOOTER_get() {
87673   int jresult ;
87674   int result;
87675
87676   result = (int)Dali::Toolkit::Popup::Property::FOOTER;
87677   jresult = (int)result;
87678   return jresult;
87679 }
87680
87681
87682 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_DISPLAY_STATE_get() {
87683   int jresult ;
87684   int result;
87685
87686   result = (int)Dali::Toolkit::Popup::Property::DISPLAY_STATE;
87687   jresult = (int)result;
87688   return jresult;
87689 }
87690
87691
87692 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TOUCH_TRANSPARENT_get() {
87693   int jresult ;
87694   int result;
87695
87696   result = (int)Dali::Toolkit::Popup::Property::TOUCH_TRANSPARENT;
87697   jresult = (int)result;
87698   return jresult;
87699 }
87700
87701
87702 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_VISIBILITY_get() {
87703   int jresult ;
87704   int result;
87705
87706   result = (int)Dali::Toolkit::Popup::Property::TAIL_VISIBILITY;
87707   jresult = (int)result;
87708   return jresult;
87709 }
87710
87711
87712 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_POSITION_get() {
87713   int jresult ;
87714   int result;
87715
87716   result = (int)Dali::Toolkit::Popup::Property::TAIL_POSITION;
87717   jresult = (int)result;
87718   return jresult;
87719 }
87720
87721
87722 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTEXTUAL_MODE_get() {
87723   int jresult ;
87724   int result;
87725
87726   result = (int)Dali::Toolkit::Popup::Property::CONTEXTUAL_MODE;
87727   jresult = (int)result;
87728   return jresult;
87729 }
87730
87731
87732 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_DURATION_get() {
87733   int jresult ;
87734   int result;
87735
87736   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_DURATION;
87737   jresult = (int)result;
87738   return jresult;
87739 }
87740
87741
87742 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_MODE_get() {
87743   int jresult ;
87744   int result;
87745
87746   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_MODE;
87747   jresult = (int)result;
87748   return jresult;
87749 }
87750
87751
87752 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ENTRY_ANIMATION_get() {
87753   int jresult ;
87754   int result;
87755
87756   result = (int)Dali::Toolkit::Popup::Property::ENTRY_ANIMATION;
87757   jresult = (int)result;
87758   return jresult;
87759 }
87760
87761
87762 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_EXIT_ANIMATION_get() {
87763   int jresult ;
87764   int result;
87765
87766   result = (int)Dali::Toolkit::Popup::Property::EXIT_ANIMATION;
87767   jresult = (int)result;
87768   return jresult;
87769 }
87770
87771
87772 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_AUTO_HIDE_DELAY_get() {
87773   int jresult ;
87774   int result;
87775
87776   result = (int)Dali::Toolkit::Popup::Property::AUTO_HIDE_DELAY;
87777   jresult = (int)result;
87778   return jresult;
87779 }
87780
87781
87782 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_ENABLED_get() {
87783   int jresult ;
87784   int result;
87785
87786   result = (int)Dali::Toolkit::Popup::Property::BACKING_ENABLED;
87787   jresult = (int)result;
87788   return jresult;
87789 }
87790
87791
87792 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_COLOR_get() {
87793   int jresult ;
87794   int result;
87795
87796   result = (int)Dali::Toolkit::Popup::Property::BACKING_COLOR;
87797   jresult = (int)result;
87798   return jresult;
87799 }
87800
87801
87802 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_IMAGE_get() {
87803   int jresult ;
87804   int result;
87805
87806   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_IMAGE;
87807   jresult = (int)result;
87808   return jresult;
87809 }
87810
87811
87812 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_BORDER_get() {
87813   int jresult ;
87814   int result;
87815
87816   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_BORDER;
87817   jresult = (int)result;
87818   return jresult;
87819 }
87820
87821
87822 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_UP_IMAGE_get() {
87823   int jresult ;
87824   int result;
87825
87826   result = (int)Dali::Toolkit::Popup::Property::TAIL_UP_IMAGE;
87827   jresult = (int)result;
87828   return jresult;
87829 }
87830
87831
87832 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_DOWN_IMAGE_get() {
87833   int jresult ;
87834   int result;
87835
87836   result = (int)Dali::Toolkit::Popup::Property::TAIL_DOWN_IMAGE;
87837   jresult = (int)result;
87838   return jresult;
87839 }
87840
87841
87842 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_LEFT_IMAGE_get() {
87843   int jresult ;
87844   int result;
87845
87846   result = (int)Dali::Toolkit::Popup::Property::TAIL_LEFT_IMAGE;
87847   jresult = (int)result;
87848   return jresult;
87849 }
87850
87851
87852 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_RIGHT_IMAGE_get() {
87853   int jresult ;
87854   int result;
87855
87856   result = (int)Dali::Toolkit::Popup::Property::TAIL_RIGHT_IMAGE;
87857   jresult = (int)result;
87858   return jresult;
87859 }
87860
87861
87862 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup_Property() {
87863   void * jresult ;
87864   Dali::Toolkit::Popup::Property *result = 0 ;
87865
87866   {
87867     try {
87868       result = (Dali::Toolkit::Popup::Property *)new Dali::Toolkit::Popup::Property();
87869     } catch (std::out_of_range& e) {
87870       {
87871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87872       };
87873     } catch (std::exception& e) {
87874       {
87875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87876       };
87877     } catch (Dali::DaliException e) {
87878       {
87879         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87880       };
87881     } catch (...) {
87882       {
87883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87884       };
87885     }
87886   }
87887
87888   jresult = (void *)result;
87889   return jresult;
87890 }
87891
87892
87893 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup_Property(void * jarg1) {
87894   Dali::Toolkit::Popup::Property *arg1 = (Dali::Toolkit::Popup::Property *) 0 ;
87895
87896   arg1 = (Dali::Toolkit::Popup::Property *)jarg1;
87897   {
87898     try {
87899       delete arg1;
87900     } catch (std::out_of_range& e) {
87901       {
87902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87903       };
87904     } catch (std::exception& e) {
87905       {
87906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87907       };
87908     } catch (Dali::DaliException e) {
87909       {
87910         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87911       };
87912     } catch (...) {
87913       {
87914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87915       };
87916     }
87917   }
87918
87919 }
87920
87921
87922 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_0() {
87923   void * jresult ;
87924   Dali::Toolkit::Popup *result = 0 ;
87925
87926   {
87927     try {
87928       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup();
87929     } catch (std::out_of_range& e) {
87930       {
87931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87932       };
87933     } catch (std::exception& e) {
87934       {
87935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87936       };
87937     } catch (Dali::DaliException e) {
87938       {
87939         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87940       };
87941     } catch (...) {
87942       {
87943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87944       };
87945     }
87946   }
87947
87948   jresult = (void *)result;
87949   return jresult;
87950 }
87951
87952
87953 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_New() {
87954   void * jresult ;
87955   Dali::Toolkit::Popup result;
87956
87957   {
87958     try {
87959       result = Dali::Toolkit::Popup::New();
87960     } catch (std::out_of_range& e) {
87961       {
87962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87963       };
87964     } catch (std::exception& e) {
87965       {
87966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87967       };
87968     } catch (Dali::DaliException e) {
87969       {
87970         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87971       };
87972     } catch (...) {
87973       {
87974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87975       };
87976     }
87977   }
87978
87979   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
87980   return jresult;
87981 }
87982
87983
87984 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup(void * jarg1) {
87985   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87986
87987   arg1 = (Dali::Toolkit::Popup *)jarg1;
87988   {
87989     try {
87990       delete arg1;
87991     } catch (std::out_of_range& e) {
87992       {
87993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87994       };
87995     } catch (std::exception& e) {
87996       {
87997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87998       };
87999     } catch (Dali::DaliException e) {
88000       {
88001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88002       };
88003     } catch (...) {
88004       {
88005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88006       };
88007     }
88008   }
88009
88010 }
88011
88012
88013 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_1(void * jarg1) {
88014   void * jresult ;
88015   Dali::Toolkit::Popup *arg1 = 0 ;
88016   Dali::Toolkit::Popup *result = 0 ;
88017
88018   arg1 = (Dali::Toolkit::Popup *)jarg1;
88019   if (!arg1) {
88020     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
88021     return 0;
88022   }
88023   {
88024     try {
88025       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup((Dali::Toolkit::Popup const &)*arg1);
88026     } catch (std::out_of_range& e) {
88027       {
88028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88029       };
88030     } catch (std::exception& e) {
88031       {
88032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88033       };
88034     } catch (Dali::DaliException e) {
88035       {
88036         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88037       };
88038     } catch (...) {
88039       {
88040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88041       };
88042     }
88043   }
88044
88045   jresult = (void *)result;
88046   return jresult;
88047 }
88048
88049
88050 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_Assign(void * jarg1, void * jarg2) {
88051   void * jresult ;
88052   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88053   Dali::Toolkit::Popup *arg2 = 0 ;
88054   Dali::Toolkit::Popup *result = 0 ;
88055
88056   arg1 = (Dali::Toolkit::Popup *)jarg1;
88057   arg2 = (Dali::Toolkit::Popup *)jarg2;
88058   if (!arg2) {
88059     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
88060     return 0;
88061   }
88062   {
88063     try {
88064       result = (Dali::Toolkit::Popup *) &(arg1)->operator =((Dali::Toolkit::Popup const &)*arg2);
88065     } catch (std::out_of_range& e) {
88066       {
88067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88068       };
88069     } catch (std::exception& e) {
88070       {
88071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88072       };
88073     } catch (Dali::DaliException e) {
88074       {
88075         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88076       };
88077     } catch (...) {
88078       {
88079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88080       };
88081     }
88082   }
88083
88084   jresult = (void *)result;
88085   return jresult;
88086 }
88087
88088
88089 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_DownCast(void * jarg1) {
88090   void * jresult ;
88091   Dali::BaseHandle arg1 ;
88092   Dali::BaseHandle *argp1 ;
88093   Dali::Toolkit::Popup result;
88094
88095   argp1 = (Dali::BaseHandle *)jarg1;
88096   if (!argp1) {
88097     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
88098     return 0;
88099   }
88100   arg1 = *argp1;
88101   {
88102     try {
88103       result = Dali::Toolkit::Popup::DownCast(arg1);
88104     } catch (std::out_of_range& e) {
88105       {
88106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88107       };
88108     } catch (std::exception& e) {
88109       {
88110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88111       };
88112     } catch (Dali::DaliException e) {
88113       {
88114         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88115       };
88116     } catch (...) {
88117       {
88118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88119       };
88120     }
88121   }
88122
88123   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
88124   return jresult;
88125 }
88126
88127
88128 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetTitle(void * jarg1, void * jarg2) {
88129   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88130   Dali::Actor arg2 ;
88131   Dali::Actor *argp2 ;
88132
88133   arg1 = (Dali::Toolkit::Popup *)jarg1;
88134   argp2 = (Dali::Actor *)jarg2;
88135   if (!argp2) {
88136     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88137     return ;
88138   }
88139   arg2 = *argp2;
88140   {
88141     try {
88142       (arg1)->SetTitle(arg2);
88143     } catch (std::out_of_range& e) {
88144       {
88145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88146       };
88147     } catch (std::exception& e) {
88148       {
88149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88150       };
88151     } catch (Dali::DaliException e) {
88152       {
88153         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88154       };
88155     } catch (...) {
88156       {
88157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88158       };
88159     }
88160   }
88161
88162 }
88163
88164
88165 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetTitle(void * jarg1) {
88166   void * jresult ;
88167   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88168   Dali::Actor result;
88169
88170   arg1 = (Dali::Toolkit::Popup *)jarg1;
88171   {
88172     try {
88173       result = ((Dali::Toolkit::Popup const *)arg1)->GetTitle();
88174     } catch (std::out_of_range& e) {
88175       {
88176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88177       };
88178     } catch (std::exception& e) {
88179       {
88180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88181       };
88182     } catch (Dali::DaliException e) {
88183       {
88184         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88185       };
88186     } catch (...) {
88187       {
88188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88189       };
88190     }
88191   }
88192
88193   jresult = new Dali::Actor((const Dali::Actor &)result);
88194   return jresult;
88195 }
88196
88197
88198 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetContent(void * jarg1, void * jarg2) {
88199   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88200   Dali::Actor arg2 ;
88201   Dali::Actor *argp2 ;
88202
88203   arg1 = (Dali::Toolkit::Popup *)jarg1;
88204   argp2 = (Dali::Actor *)jarg2;
88205   if (!argp2) {
88206     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88207     return ;
88208   }
88209   arg2 = *argp2;
88210   {
88211     try {
88212       (arg1)->SetContent(arg2);
88213     } catch (std::out_of_range& e) {
88214       {
88215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88216       };
88217     } catch (std::exception& e) {
88218       {
88219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88220       };
88221     } catch (Dali::DaliException e) {
88222       {
88223         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88224       };
88225     } catch (...) {
88226       {
88227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88228       };
88229     }
88230   }
88231
88232 }
88233
88234
88235 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetContent(void * jarg1) {
88236   void * jresult ;
88237   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88238   Dali::Actor result;
88239
88240   arg1 = (Dali::Toolkit::Popup *)jarg1;
88241   {
88242     try {
88243       result = ((Dali::Toolkit::Popup const *)arg1)->GetContent();
88244     } catch (std::out_of_range& e) {
88245       {
88246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88247       };
88248     } catch (std::exception& e) {
88249       {
88250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88251       };
88252     } catch (Dali::DaliException e) {
88253       {
88254         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88255       };
88256     } catch (...) {
88257       {
88258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88259       };
88260     }
88261   }
88262
88263   jresult = new Dali::Actor((const Dali::Actor &)result);
88264   return jresult;
88265 }
88266
88267
88268 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetFooter(void * jarg1, void * jarg2) {
88269   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88270   Dali::Actor arg2 ;
88271   Dali::Actor *argp2 ;
88272
88273   arg1 = (Dali::Toolkit::Popup *)jarg1;
88274   argp2 = (Dali::Actor *)jarg2;
88275   if (!argp2) {
88276     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88277     return ;
88278   }
88279   arg2 = *argp2;
88280   {
88281     try {
88282       (arg1)->SetFooter(arg2);
88283     } catch (std::out_of_range& e) {
88284       {
88285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88286       };
88287     } catch (std::exception& e) {
88288       {
88289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88290       };
88291     } catch (Dali::DaliException e) {
88292       {
88293         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88294       };
88295     } catch (...) {
88296       {
88297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88298       };
88299     }
88300   }
88301
88302 }
88303
88304
88305 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetFooter(void * jarg1) {
88306   void * jresult ;
88307   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88308   Dali::Actor result;
88309
88310   arg1 = (Dali::Toolkit::Popup *)jarg1;
88311   {
88312     try {
88313       result = ((Dali::Toolkit::Popup const *)arg1)->GetFooter();
88314     } catch (std::out_of_range& e) {
88315       {
88316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88317       };
88318     } catch (std::exception& e) {
88319       {
88320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88321       };
88322     } catch (Dali::DaliException e) {
88323       {
88324         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88325       };
88326     } catch (...) {
88327       {
88328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88329       };
88330     }
88331   }
88332
88333   jresult = new Dali::Actor((const Dali::Actor &)result);
88334   return jresult;
88335 }
88336
88337
88338 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetDisplayState(void * jarg1, int jarg2) {
88339   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88340   Dali::Toolkit::Popup::DisplayState arg2 ;
88341
88342   arg1 = (Dali::Toolkit::Popup *)jarg1;
88343   arg2 = (Dali::Toolkit::Popup::DisplayState)jarg2;
88344   {
88345     try {
88346       (arg1)->SetDisplayState(arg2);
88347     } catch (std::out_of_range& e) {
88348       {
88349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88350       };
88351     } catch (std::exception& e) {
88352       {
88353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88354       };
88355     } catch (Dali::DaliException e) {
88356       {
88357         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88358       };
88359     } catch (...) {
88360       {
88361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88362       };
88363     }
88364   }
88365
88366 }
88367
88368
88369 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_GetDisplayState(void * jarg1) {
88370   int jresult ;
88371   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88372   Dali::Toolkit::Popup::DisplayState result;
88373
88374   arg1 = (Dali::Toolkit::Popup *)jarg1;
88375   {
88376     try {
88377       result = (Dali::Toolkit::Popup::DisplayState)((Dali::Toolkit::Popup const *)arg1)->GetDisplayState();
88378     } catch (std::out_of_range& e) {
88379       {
88380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88381       };
88382     } catch (std::exception& e) {
88383       {
88384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88385       };
88386     } catch (Dali::DaliException e) {
88387       {
88388         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88389       };
88390     } catch (...) {
88391       {
88392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88393       };
88394     }
88395   }
88396
88397   jresult = (int)result;
88398   return jresult;
88399 }
88400
88401
88402 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_OutsideTouchedSignal(void * jarg1) {
88403   void * jresult ;
88404   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88405   Dali::Toolkit::Popup::TouchedOutsideSignalType *result = 0 ;
88406
88407   arg1 = (Dali::Toolkit::Popup *)jarg1;
88408   {
88409     try {
88410       result = (Dali::Toolkit::Popup::TouchedOutsideSignalType *) &(arg1)->OutsideTouchedSignal();
88411     } catch (std::out_of_range& e) {
88412       {
88413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88414       };
88415     } catch (std::exception& e) {
88416       {
88417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88418       };
88419     } catch (Dali::DaliException e) {
88420       {
88421         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88422       };
88423     } catch (...) {
88424       {
88425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88426       };
88427     }
88428   }
88429
88430   jresult = (void *)result;
88431   return jresult;
88432 }
88433
88434
88435 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShowingSignal(void * jarg1) {
88436   void * jresult ;
88437   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88438   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
88439
88440   arg1 = (Dali::Toolkit::Popup *)jarg1;
88441   {
88442     try {
88443       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShowingSignal();
88444     } catch (std::out_of_range& e) {
88445       {
88446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88447       };
88448     } catch (std::exception& e) {
88449       {
88450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88451       };
88452     } catch (Dali::DaliException e) {
88453       {
88454         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88455       };
88456     } catch (...) {
88457       {
88458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88459       };
88460     }
88461   }
88462
88463   jresult = (void *)result;
88464   return jresult;
88465 }
88466
88467
88468 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShownSignal(void * jarg1) {
88469   void * jresult ;
88470   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88471   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
88472
88473   arg1 = (Dali::Toolkit::Popup *)jarg1;
88474   {
88475     try {
88476       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShownSignal();
88477     } catch (std::out_of_range& e) {
88478       {
88479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88480       };
88481     } catch (std::exception& e) {
88482       {
88483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88484       };
88485     } catch (Dali::DaliException e) {
88486       {
88487         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88488       };
88489     } catch (...) {
88490       {
88491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88492       };
88493     }
88494   }
88495
88496   jresult = (void *)result;
88497   return jresult;
88498 }
88499
88500
88501 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HidingSignal(void * jarg1) {
88502   void * jresult ;
88503   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88504   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
88505
88506   arg1 = (Dali::Toolkit::Popup *)jarg1;
88507   {
88508     try {
88509       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HidingSignal();
88510     } catch (std::out_of_range& e) {
88511       {
88512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88513       };
88514     } catch (std::exception& e) {
88515       {
88516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88517       };
88518     } catch (Dali::DaliException e) {
88519       {
88520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88521       };
88522     } catch (...) {
88523       {
88524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88525       };
88526     }
88527   }
88528
88529   jresult = (void *)result;
88530   return jresult;
88531 }
88532
88533
88534 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HiddenSignal(void * jarg1) {
88535   void * jresult ;
88536   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88537   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
88538
88539   arg1 = (Dali::Toolkit::Popup *)jarg1;
88540   {
88541     try {
88542       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HiddenSignal();
88543     } catch (std::out_of_range& e) {
88544       {
88545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88546       };
88547     } catch (std::exception& e) {
88548       {
88549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88550       };
88551     } catch (Dali::DaliException e) {
88552       {
88553         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88554       };
88555     } catch (...) {
88556       {
88557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88558       };
88559     }
88560   }
88561
88562   jresult = (void *)result;
88563   return jresult;
88564 }
88565
88566
88567 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VALUE_get() {
88568   int jresult ;
88569   int result;
88570
88571   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VALUE;
88572   jresult = (int)result;
88573   return jresult;
88574 }
88575
88576
88577 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VALUE_get() {
88578   int jresult ;
88579   int result;
88580
88581   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VALUE;
88582   jresult = (int)result;
88583   return jresult;
88584 }
88585
88586
88587 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_get() {
88588   int jresult ;
88589   int result;
88590
88591   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE;
88592   jresult = (int)result;
88593   return jresult;
88594 }
88595
88596
88597 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_TRACK_VISUAL_get() {
88598   int jresult ;
88599   int result;
88600
88601   result = (int)Dali::Toolkit::ProgressBar::Property::TRACK_VISUAL;
88602   jresult = (int)result;
88603   return jresult;
88604 }
88605
88606
88607 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VISUAL_get() {
88608   int jresult ;
88609   int result;
88610
88611   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VISUAL;
88612   jresult = (int)result;
88613   return jresult;
88614 }
88615
88616
88617 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VISUAL_get() {
88618   int jresult ;
88619   int result;
88620
88621   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VISUAL;
88622   jresult = (int)result;
88623   return jresult;
88624 }
88625
88626
88627 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_get() {
88628   int jresult ;
88629   int result;
88630
88631   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL;
88632   jresult = (int)result;
88633   return jresult;
88634 }
88635
88636
88637 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_ANIMATION_get() {
88638   int jresult ;
88639   int result;
88640
88641   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL_ANIMATION;
88642   jresult = (int)result;
88643   return jresult;
88644 }
88645
88646
88647 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_LABEL_VISUAL_get() {
88648   int jresult ;
88649   int result;
88650
88651   result = (int)Dali::Toolkit::ProgressBar::Property::LABEL_VISUAL;
88652   jresult = (int)result;
88653   return jresult;
88654 }
88655
88656
88657 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar_Property() {
88658   void * jresult ;
88659   Dali::Toolkit::ProgressBar::Property *result = 0 ;
88660
88661   {
88662     try {
88663       result = (Dali::Toolkit::ProgressBar::Property *)new Dali::Toolkit::ProgressBar::Property();
88664     } catch (std::out_of_range& e) {
88665       {
88666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88667       };
88668     } catch (std::exception& e) {
88669       {
88670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88671       };
88672     } catch (Dali::DaliException e) {
88673       {
88674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88675       };
88676     } catch (...) {
88677       {
88678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88679       };
88680     }
88681   }
88682
88683   jresult = (void *)result;
88684   return jresult;
88685 }
88686
88687
88688 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar_Property(void * jarg1) {
88689   Dali::Toolkit::ProgressBar::Property *arg1 = (Dali::Toolkit::ProgressBar::Property *) 0 ;
88690
88691   arg1 = (Dali::Toolkit::ProgressBar::Property *)jarg1;
88692   {
88693     try {
88694       delete arg1;
88695     } catch (std::out_of_range& e) {
88696       {
88697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88698       };
88699     } catch (std::exception& e) {
88700       {
88701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88702       };
88703     } catch (Dali::DaliException e) {
88704       {
88705         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88706       };
88707     } catch (...) {
88708       {
88709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88710       };
88711     }
88712   }
88713
88714 }
88715
88716
88717 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_New() {
88718   void * jresult ;
88719   Dali::Toolkit::ProgressBar result;
88720
88721   {
88722     try {
88723       result = Dali::Toolkit::ProgressBar::New();
88724     } catch (std::out_of_range& e) {
88725       {
88726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88727       };
88728     } catch (std::exception& e) {
88729       {
88730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88731       };
88732     } catch (Dali::DaliException e) {
88733       {
88734         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88735       };
88736     } catch (...) {
88737       {
88738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88739       };
88740     }
88741   }
88742
88743   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
88744   return jresult;
88745 }
88746
88747
88748 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_0() {
88749   void * jresult ;
88750   Dali::Toolkit::ProgressBar *result = 0 ;
88751
88752   {
88753     try {
88754       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar();
88755     } catch (std::out_of_range& e) {
88756       {
88757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88758       };
88759     } catch (std::exception& e) {
88760       {
88761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88762       };
88763     } catch (Dali::DaliException e) {
88764       {
88765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88766       };
88767     } catch (...) {
88768       {
88769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88770       };
88771     }
88772   }
88773
88774   jresult = (void *)result;
88775   return jresult;
88776 }
88777
88778
88779 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_1(void * jarg1) {
88780   void * jresult ;
88781   Dali::Toolkit::ProgressBar *arg1 = 0 ;
88782   Dali::Toolkit::ProgressBar *result = 0 ;
88783
88784   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
88785   if (!arg1) {
88786     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
88787     return 0;
88788   }
88789   {
88790     try {
88791       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar((Dali::Toolkit::ProgressBar const &)*arg1);
88792     } catch (std::out_of_range& e) {
88793       {
88794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88795       };
88796     } catch (std::exception& e) {
88797       {
88798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88799       };
88800     } catch (Dali::DaliException e) {
88801       {
88802         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88803       };
88804     } catch (...) {
88805       {
88806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88807       };
88808     }
88809   }
88810
88811   jresult = (void *)result;
88812   return jresult;
88813 }
88814
88815
88816 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_Assign(void * jarg1, void * jarg2) {
88817   void * jresult ;
88818   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
88819   Dali::Toolkit::ProgressBar *arg2 = 0 ;
88820   Dali::Toolkit::ProgressBar *result = 0 ;
88821
88822   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
88823   arg2 = (Dali::Toolkit::ProgressBar *)jarg2;
88824   if (!arg2) {
88825     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
88826     return 0;
88827   }
88828   {
88829     try {
88830       result = (Dali::Toolkit::ProgressBar *) &(arg1)->operator =((Dali::Toolkit::ProgressBar const &)*arg2);
88831     } catch (std::out_of_range& e) {
88832       {
88833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88834       };
88835     } catch (std::exception& e) {
88836       {
88837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88838       };
88839     } catch (Dali::DaliException e) {
88840       {
88841         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88842       };
88843     } catch (...) {
88844       {
88845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88846       };
88847     }
88848   }
88849
88850   jresult = (void *)result;
88851   return jresult;
88852 }
88853
88854
88855 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar(void * jarg1) {
88856   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
88857
88858   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
88859   {
88860     try {
88861       delete arg1;
88862     } catch (std::out_of_range& e) {
88863       {
88864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88865       };
88866     } catch (std::exception& e) {
88867       {
88868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88869       };
88870     } catch (Dali::DaliException e) {
88871       {
88872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88873       };
88874     } catch (...) {
88875       {
88876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88877       };
88878     }
88879   }
88880
88881 }
88882
88883
88884 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_DownCast(void * jarg1) {
88885   void * jresult ;
88886   Dali::BaseHandle arg1 ;
88887   Dali::BaseHandle *argp1 ;
88888   Dali::Toolkit::ProgressBar result;
88889
88890   argp1 = (Dali::BaseHandle *)jarg1;
88891   if (!argp1) {
88892     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
88893     return 0;
88894   }
88895   arg1 = *argp1;
88896   {
88897     try {
88898       result = Dali::Toolkit::ProgressBar::DownCast(arg1);
88899     } catch (std::out_of_range& e) {
88900       {
88901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88902       };
88903     } catch (std::exception& e) {
88904       {
88905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88906       };
88907     } catch (Dali::DaliException e) {
88908       {
88909         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88910       };
88911     } catch (...) {
88912       {
88913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88914       };
88915     }
88916   }
88917
88918   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
88919   return jresult;
88920 }
88921
88922
88923 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_ValueChangedSignal(void * jarg1) {
88924   void * jresult ;
88925   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
88926   Dali::Toolkit::ProgressBar::ValueChangedSignalType *result = 0 ;
88927
88928   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
88929   {
88930     try {
88931       result = (Dali::Toolkit::ProgressBar::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
88932     } catch (std::out_of_range& e) {
88933       {
88934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88935       };
88936     } catch (std::exception& e) {
88937       {
88938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88939       };
88940     } catch (Dali::DaliException e) {
88941       {
88942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88943       };
88944     } catch (...) {
88945       {
88946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88947       };
88948     }
88949   }
88950
88951   jresult = (void *)result;
88952   return jresult;
88953 }
88954
88955
88956 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_0() {
88957   void * jresult ;
88958   Dali::Toolkit::GaussianBlurView *result = 0 ;
88959
88960   {
88961     try {
88962       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView();
88963     } catch (std::out_of_range& e) {
88964       {
88965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88966       };
88967     } catch (std::exception& e) {
88968       {
88969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88970       };
88971     } catch (Dali::DaliException e) {
88972       {
88973         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88974       };
88975     } catch (...) {
88976       {
88977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88978       };
88979     }
88980   }
88981
88982   jresult = (void *)result;
88983   return jresult;
88984 }
88985
88986
88987 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_1(void * jarg1) {
88988   void * jresult ;
88989   Dali::Toolkit::GaussianBlurView *arg1 = 0 ;
88990   Dali::Toolkit::GaussianBlurView *result = 0 ;
88991
88992   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
88993   if (!arg1) {
88994     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
88995     return 0;
88996   }
88997   {
88998     try {
88999       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView((Dali::Toolkit::GaussianBlurView const &)*arg1);
89000     } catch (std::out_of_range& e) {
89001       {
89002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89003       };
89004     } catch (std::exception& e) {
89005       {
89006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89007       };
89008     } catch (Dali::DaliException e) {
89009       {
89010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89011       };
89012     } catch (...) {
89013       {
89014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89015       };
89016     }
89017   }
89018
89019   jresult = (void *)result;
89020   return jresult;
89021 }
89022
89023
89024 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_Assign(void * jarg1, void * jarg2) {
89025   void * jresult ;
89026   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89027   Dali::Toolkit::GaussianBlurView *arg2 = 0 ;
89028   Dali::Toolkit::GaussianBlurView *result = 0 ;
89029
89030   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89031   arg2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
89032   if (!arg2) {
89033     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
89034     return 0;
89035   }
89036   {
89037     try {
89038       result = (Dali::Toolkit::GaussianBlurView *) &(arg1)->operator =((Dali::Toolkit::GaussianBlurView const &)*arg2);
89039     } catch (std::out_of_range& e) {
89040       {
89041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89042       };
89043     } catch (std::exception& e) {
89044       {
89045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89046       };
89047     } catch (Dali::DaliException e) {
89048       {
89049         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89050       };
89051     } catch (...) {
89052       {
89053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89054       };
89055     }
89056   }
89057
89058   jresult = (void *)result;
89059   return jresult;
89060 }
89061
89062
89063 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurView(void * jarg1) {
89064   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89065
89066   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89067   {
89068     try {
89069       delete arg1;
89070     } catch (std::out_of_range& e) {
89071       {
89072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89073       };
89074     } catch (std::exception& e) {
89075       {
89076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89077       };
89078     } catch (Dali::DaliException e) {
89079       {
89080         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89081       };
89082     } catch (...) {
89083       {
89084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89085       };
89086     }
89087   }
89088
89089 }
89090
89091
89092 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_DownCast(void * jarg1) {
89093   void * jresult ;
89094   Dali::BaseHandle arg1 ;
89095   Dali::BaseHandle *argp1 ;
89096   Dali::Toolkit::GaussianBlurView result;
89097
89098   argp1 = (Dali::BaseHandle *)jarg1;
89099   if (!argp1) {
89100     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
89101     return 0;
89102   }
89103   arg1 = *argp1;
89104   {
89105     try {
89106       result = Dali::Toolkit::GaussianBlurView::DownCast(arg1);
89107     } catch (std::out_of_range& e) {
89108       {
89109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89110       };
89111     } catch (std::exception& e) {
89112       {
89113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89114       };
89115     } catch (Dali::DaliException e) {
89116       {
89117         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89118       };
89119     } catch (...) {
89120       {
89121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89122       };
89123     }
89124   }
89125
89126   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
89127   return jresult;
89128 }
89129
89130
89131 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_0() {
89132   void * jresult ;
89133   Dali::Toolkit::GaussianBlurView result;
89134
89135   {
89136     try {
89137       result = Dali::Toolkit::GaussianBlurView::New();
89138     } catch (std::out_of_range& e) {
89139       {
89140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89141       };
89142     } catch (std::exception& e) {
89143       {
89144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89145       };
89146     } catch (Dali::DaliException e) {
89147       {
89148         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89149       };
89150     } catch (...) {
89151       {
89152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89153       };
89154     }
89155   }
89156
89157   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
89158   return jresult;
89159 }
89160
89161
89162 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_1(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5, unsigned int jarg6) {
89163   void * jresult ;
89164   unsigned int arg1 ;
89165   float arg2 ;
89166   Dali::Pixel::Format arg3 ;
89167   float arg4 ;
89168   float arg5 ;
89169   bool arg6 ;
89170   Dali::Toolkit::GaussianBlurView result;
89171
89172   arg1 = (unsigned int)jarg1;
89173   arg2 = (float)jarg2;
89174   arg3 = (Dali::Pixel::Format)jarg3;
89175   arg4 = (float)jarg4;
89176   arg5 = (float)jarg5;
89177   arg6 = jarg6 ? true : false;
89178   {
89179     try {
89180       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5,arg6);
89181     } catch (std::out_of_range& e) {
89182       {
89183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89184       };
89185     } catch (std::exception& e) {
89186       {
89187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89188       };
89189     } catch (Dali::DaliException e) {
89190       {
89191         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89192       };
89193     } catch (...) {
89194       {
89195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89196       };
89197     }
89198   }
89199
89200   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
89201   return jresult;
89202 }
89203
89204
89205 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_2(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5) {
89206   void * jresult ;
89207   unsigned int arg1 ;
89208   float arg2 ;
89209   Dali::Pixel::Format arg3 ;
89210   float arg4 ;
89211   float arg5 ;
89212   Dali::Toolkit::GaussianBlurView result;
89213
89214   arg1 = (unsigned int)jarg1;
89215   arg2 = (float)jarg2;
89216   arg3 = (Dali::Pixel::Format)jarg3;
89217   arg4 = (float)jarg4;
89218   arg5 = (float)jarg5;
89219   {
89220     try {
89221       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5);
89222     } catch (std::out_of_range& e) {
89223       {
89224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89225       };
89226     } catch (std::exception& e) {
89227       {
89228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89229       };
89230     } catch (Dali::DaliException e) {
89231       {
89232         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89233       };
89234     } catch (...) {
89235       {
89236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89237       };
89238     }
89239   }
89240
89241   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
89242   return jresult;
89243 }
89244
89245
89246 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Add(void * jarg1, void * jarg2) {
89247   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89248   Dali::Actor arg2 ;
89249   Dali::Actor *argp2 ;
89250
89251   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89252   argp2 = (Dali::Actor *)jarg2;
89253   if (!argp2) {
89254     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
89255     return ;
89256   }
89257   arg2 = *argp2;
89258   {
89259     try {
89260       (arg1)->Add(arg2);
89261     } catch (std::out_of_range& e) {
89262       {
89263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89264       };
89265     } catch (std::exception& e) {
89266       {
89267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89268       };
89269     } catch (Dali::DaliException e) {
89270       {
89271         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89272       };
89273     } catch (...) {
89274       {
89275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89276       };
89277     }
89278   }
89279
89280 }
89281
89282
89283 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Remove(void * jarg1, void * jarg2) {
89284   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89285   Dali::Actor arg2 ;
89286   Dali::Actor *argp2 ;
89287
89288   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89289   argp2 = (Dali::Actor *)jarg2;
89290   if (!argp2) {
89291     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
89292     return ;
89293   }
89294   arg2 = *argp2;
89295   {
89296     try {
89297       (arg1)->Remove(arg2);
89298     } catch (std::out_of_range& e) {
89299       {
89300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89301       };
89302     } catch (std::exception& e) {
89303       {
89304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89305       };
89306     } catch (Dali::DaliException e) {
89307       {
89308         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89309       };
89310     } catch (...) {
89311       {
89312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89313       };
89314     }
89315   }
89316
89317 }
89318
89319
89320 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Activate(void * jarg1) {
89321   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89322
89323   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89324   {
89325     try {
89326       (arg1)->Activate();
89327     } catch (std::out_of_range& e) {
89328       {
89329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89330       };
89331     } catch (std::exception& e) {
89332       {
89333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89334       };
89335     } catch (Dali::DaliException e) {
89336       {
89337         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89338       };
89339     } catch (...) {
89340       {
89341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89342       };
89343     }
89344   }
89345
89346 }
89347
89348
89349 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_ActivateOnce(void * jarg1) {
89350   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89351
89352   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89353   {
89354     try {
89355       (arg1)->ActivateOnce();
89356     } catch (std::out_of_range& e) {
89357       {
89358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89359       };
89360     } catch (std::exception& e) {
89361       {
89362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89363       };
89364     } catch (Dali::DaliException e) {
89365       {
89366         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89367       };
89368     } catch (...) {
89369       {
89370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89371       };
89372     }
89373   }
89374
89375 }
89376
89377
89378 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Deactivate(void * jarg1) {
89379   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89380
89381   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89382   {
89383     try {
89384       (arg1)->Deactivate();
89385     } catch (std::out_of_range& e) {
89386       {
89387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89388       };
89389     } catch (std::exception& e) {
89390       {
89391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89392       };
89393     } catch (Dali::DaliException e) {
89394       {
89395         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89396       };
89397     } catch (...) {
89398       {
89399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89400       };
89401     }
89402   }
89403
89404 }
89405
89406
89407 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetUserImageAndOutputRenderTarget(void * jarg1, void * jarg2, void * jarg3) {
89408   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89409   Dali::Image arg2 ;
89410   Dali::FrameBufferImage arg3 ;
89411   Dali::Image *argp2 ;
89412   Dali::FrameBufferImage *argp3 ;
89413
89414   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89415   argp2 = (Dali::Image *)jarg2;
89416   if (!argp2) {
89417     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
89418     return ;
89419   }
89420   arg2 = *argp2;
89421   argp3 = (Dali::FrameBufferImage *)jarg3;
89422   if (!argp3) {
89423     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBufferImage", 0);
89424     return ;
89425   }
89426   arg3 = *argp3;
89427   {
89428     try {
89429       (arg1)->SetUserImageAndOutputRenderTarget(arg2,arg3);
89430     } catch (std::out_of_range& e) {
89431       {
89432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89433       };
89434     } catch (std::exception& e) {
89435       {
89436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89437       };
89438     } catch (Dali::DaliException e) {
89439       {
89440         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89441       };
89442     } catch (...) {
89443       {
89444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89445       };
89446     }
89447   }
89448
89449 }
89450
89451
89452 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurStrengthPropertyIndex(void * jarg1) {
89453   int jresult ;
89454   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89455   Dali::Property::Index result;
89456
89457   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89458   {
89459     try {
89460       result = (Dali::Property::Index)((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurStrengthPropertyIndex();
89461     } catch (std::out_of_range& e) {
89462       {
89463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89464       };
89465     } catch (std::exception& e) {
89466       {
89467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89468       };
89469     } catch (Dali::DaliException e) {
89470       {
89471         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89472       };
89473     } catch (...) {
89474       {
89475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89476       };
89477     }
89478   }
89479
89480   jresult = result;
89481   return jresult;
89482 }
89483
89484
89485 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurredRenderTarget(void * jarg1) {
89486   void * jresult ;
89487   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89488   Dali::FrameBufferImage result;
89489
89490   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89491   {
89492     try {
89493       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurredRenderTarget();
89494     } catch (std::out_of_range& e) {
89495       {
89496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89497       };
89498     } catch (std::exception& e) {
89499       {
89500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89501       };
89502     } catch (Dali::DaliException e) {
89503       {
89504         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89505       };
89506     } catch (...) {
89507       {
89508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89509       };
89510     }
89511   }
89512
89513   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
89514   return jresult;
89515 }
89516
89517
89518 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetBackgroundColor(void * jarg1, void * jarg2) {
89519   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89520   Dali::Vector4 *arg2 = 0 ;
89521
89522   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89523   arg2 = (Dali::Vector4 *)jarg2;
89524   if (!arg2) {
89525     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
89526     return ;
89527   }
89528   {
89529     try {
89530       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
89531     } catch (std::out_of_range& e) {
89532       {
89533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89534       };
89535     } catch (std::exception& e) {
89536       {
89537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89538       };
89539     } catch (Dali::DaliException e) {
89540       {
89541         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89542       };
89543     } catch (...) {
89544       {
89545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89546       };
89547     }
89548   }
89549
89550 }
89551
89552
89553 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBackgroundColor(void * jarg1) {
89554   void * jresult ;
89555   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89556   Dali::Vector4 result;
89557
89558   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89559   {
89560     try {
89561       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBackgroundColor();
89562     } catch (std::out_of_range& e) {
89563       {
89564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89565       };
89566     } catch (std::exception& e) {
89567       {
89568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89569       };
89570     } catch (Dali::DaliException e) {
89571       {
89572         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89573       };
89574     } catch (...) {
89575       {
89576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89577       };
89578     }
89579   }
89580
89581   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
89582   return jresult;
89583 }
89584
89585
89586 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_FinishedSignal(void * jarg1) {
89587   void * jresult ;
89588   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89589   Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *result = 0 ;
89590
89591   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89592   {
89593     try {
89594       result = (Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *) &(arg1)->FinishedSignal();
89595     } catch (std::out_of_range& e) {
89596       {
89597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89598       };
89599     } catch (std::exception& e) {
89600       {
89601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89602       };
89603     } catch (Dali::DaliException e) {
89604       {
89605         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89606       };
89607     } catch (...) {
89608       {
89609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89610       };
89611     }
89612   }
89613
89614   jresult = (void *)result;
89615   return jresult;
89616 }
89617
89618
89619 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageFactory(void * jarg1) {
89620   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
89621
89622   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
89623   {
89624     try {
89625       delete arg1;
89626     } catch (std::out_of_range& e) {
89627       {
89628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89629       };
89630     } catch (std::exception& e) {
89631       {
89632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89633       };
89634     } catch (Dali::DaliException e) {
89635       {
89636         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89637       };
89638     } catch (...) {
89639       {
89640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89641       };
89642     }
89643   }
89644
89645 }
89646
89647
89648 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageFactory_GetNumberOfPages(void * jarg1) {
89649   unsigned int jresult ;
89650   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
89651   unsigned int result;
89652
89653   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
89654   {
89655     try {
89656       result = (unsigned int)(arg1)->GetNumberOfPages();
89657     } catch (std::out_of_range& e) {
89658       {
89659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89660       };
89661     } catch (std::exception& e) {
89662       {
89663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89664       };
89665     } catch (Dali::DaliException e) {
89666       {
89667         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89668       };
89669     } catch (...) {
89670       {
89671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89672       };
89673     }
89674   }
89675
89676   jresult = result;
89677   return jresult;
89678 }
89679
89680
89681 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageFactory_NewPage(void * jarg1, unsigned int jarg2) {
89682   void * jresult ;
89683   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
89684   unsigned int arg2 ;
89685   Dali::Texture result;
89686
89687   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
89688   arg2 = (unsigned int)jarg2;
89689   {
89690     try {
89691       result = (arg1)->NewPage(arg2);
89692     } catch (std::out_of_range& e) {
89693       {
89694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89695       };
89696     } catch (std::exception& e) {
89697       {
89698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89699       };
89700     } catch (Dali::DaliException e) {
89701       {
89702         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89703       };
89704     } catch (...) {
89705       {
89706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89707       };
89708     }
89709   }
89710
89711   jresult = new Dali::Texture((const Dali::Texture &)result);
89712   return jresult;
89713 }
89714
89715
89716 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_PAGE_SIZE_get() {
89717   int jresult ;
89718   int result;
89719
89720   result = (int)Dali::Toolkit::PageTurnView::Property::PAGE_SIZE;
89721   jresult = (int)result;
89722   return jresult;
89723 }
89724
89725
89726 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_CURRENT_PAGE_ID_get() {
89727   int jresult ;
89728   int result;
89729
89730   result = (int)Dali::Toolkit::PageTurnView::Property::CURRENT_PAGE_ID;
89731   jresult = (int)result;
89732   return jresult;
89733 }
89734
89735
89736 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_SPINE_SHADOW_get() {
89737   int jresult ;
89738   int result;
89739
89740   result = (int)Dali::Toolkit::PageTurnView::Property::SPINE_SHADOW;
89741   jresult = (int)result;
89742   return jresult;
89743 }
89744
89745
89746 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView_Property() {
89747   void * jresult ;
89748   Dali::Toolkit::PageTurnView::Property *result = 0 ;
89749
89750   {
89751     try {
89752       result = (Dali::Toolkit::PageTurnView::Property *)new Dali::Toolkit::PageTurnView::Property();
89753     } catch (std::out_of_range& e) {
89754       {
89755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89756       };
89757     } catch (std::exception& e) {
89758       {
89759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89760       };
89761     } catch (Dali::DaliException e) {
89762       {
89763         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89764       };
89765     } catch (...) {
89766       {
89767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89768       };
89769     }
89770   }
89771
89772   jresult = (void *)result;
89773   return jresult;
89774 }
89775
89776
89777 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView_Property(void * jarg1) {
89778   Dali::Toolkit::PageTurnView::Property *arg1 = (Dali::Toolkit::PageTurnView::Property *) 0 ;
89779
89780   arg1 = (Dali::Toolkit::PageTurnView::Property *)jarg1;
89781   {
89782     try {
89783       delete arg1;
89784     } catch (std::out_of_range& e) {
89785       {
89786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89787       };
89788     } catch (std::exception& e) {
89789       {
89790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89791       };
89792     } catch (Dali::DaliException e) {
89793       {
89794         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89795       };
89796     } catch (...) {
89797       {
89798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89799       };
89800     }
89801   }
89802
89803 }
89804
89805
89806 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_0() {
89807   void * jresult ;
89808   Dali::Toolkit::PageTurnView *result = 0 ;
89809
89810   {
89811     try {
89812       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView();
89813     } catch (std::out_of_range& e) {
89814       {
89815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89816       };
89817     } catch (std::exception& e) {
89818       {
89819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89820       };
89821     } catch (Dali::DaliException e) {
89822       {
89823         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89824       };
89825     } catch (...) {
89826       {
89827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89828       };
89829     }
89830   }
89831
89832   jresult = (void *)result;
89833   return jresult;
89834 }
89835
89836
89837 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_1(void * jarg1) {
89838   void * jresult ;
89839   Dali::Toolkit::PageTurnView *arg1 = 0 ;
89840   Dali::Toolkit::PageTurnView *result = 0 ;
89841
89842   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
89843   if (!arg1) {
89844     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
89845     return 0;
89846   }
89847   {
89848     try {
89849       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView((Dali::Toolkit::PageTurnView const &)*arg1);
89850     } catch (std::out_of_range& e) {
89851       {
89852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89853       };
89854     } catch (std::exception& e) {
89855       {
89856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89857       };
89858     } catch (Dali::DaliException e) {
89859       {
89860         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89861       };
89862     } catch (...) {
89863       {
89864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89865       };
89866     }
89867   }
89868
89869   jresult = (void *)result;
89870   return jresult;
89871 }
89872
89873
89874 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_Assign(void * jarg1, void * jarg2) {
89875   void * jresult ;
89876   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
89877   Dali::Toolkit::PageTurnView *arg2 = 0 ;
89878   Dali::Toolkit::PageTurnView *result = 0 ;
89879
89880   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
89881   arg2 = (Dali::Toolkit::PageTurnView *)jarg2;
89882   if (!arg2) {
89883     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
89884     return 0;
89885   }
89886   {
89887     try {
89888       result = (Dali::Toolkit::PageTurnView *) &(arg1)->operator =((Dali::Toolkit::PageTurnView const &)*arg2);
89889     } catch (std::out_of_range& e) {
89890       {
89891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89892       };
89893     } catch (std::exception& e) {
89894       {
89895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89896       };
89897     } catch (Dali::DaliException e) {
89898       {
89899         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89900       };
89901     } catch (...) {
89902       {
89903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89904       };
89905     }
89906   }
89907
89908   jresult = (void *)result;
89909   return jresult;
89910 }
89911
89912
89913 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView(void * jarg1) {
89914   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
89915
89916   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
89917   {
89918     try {
89919       delete arg1;
89920     } catch (std::out_of_range& e) {
89921       {
89922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89923       };
89924     } catch (std::exception& e) {
89925       {
89926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89927       };
89928     } catch (Dali::DaliException e) {
89929       {
89930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89931       };
89932     } catch (...) {
89933       {
89934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89935       };
89936     }
89937   }
89938
89939 }
89940
89941
89942 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_DownCast(void * jarg1) {
89943   void * jresult ;
89944   Dali::BaseHandle arg1 ;
89945   Dali::BaseHandle *argp1 ;
89946   Dali::Toolkit::PageTurnView result;
89947
89948   argp1 = (Dali::BaseHandle *)jarg1;
89949   if (!argp1) {
89950     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
89951     return 0;
89952   }
89953   arg1 = *argp1;
89954   {
89955     try {
89956       result = Dali::Toolkit::PageTurnView::DownCast(arg1);
89957     } catch (std::out_of_range& e) {
89958       {
89959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89960       };
89961     } catch (std::exception& e) {
89962       {
89963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89964       };
89965     } catch (Dali::DaliException e) {
89966       {
89967         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89968       };
89969     } catch (...) {
89970       {
89971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89972       };
89973     }
89974   }
89975
89976   jresult = new Dali::Toolkit::PageTurnView((const Dali::Toolkit::PageTurnView &)result);
89977   return jresult;
89978 }
89979
89980
89981 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnStartedSignal(void * jarg1) {
89982   void * jresult ;
89983   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
89984   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
89985
89986   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
89987   {
89988     try {
89989       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnStartedSignal();
89990     } catch (std::out_of_range& e) {
89991       {
89992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89993       };
89994     } catch (std::exception& e) {
89995       {
89996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89997       };
89998     } catch (Dali::DaliException e) {
89999       {
90000         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90001       };
90002     } catch (...) {
90003       {
90004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90005       };
90006     }
90007   }
90008
90009   jresult = (void *)result;
90010   return jresult;
90011 }
90012
90013
90014 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnFinishedSignal(void * jarg1) {
90015   void * jresult ;
90016   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
90017   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
90018
90019   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
90020   {
90021     try {
90022       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnFinishedSignal();
90023     } catch (std::out_of_range& e) {
90024       {
90025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90026       };
90027     } catch (std::exception& e) {
90028       {
90029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90030       };
90031     } catch (Dali::DaliException e) {
90032       {
90033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90034       };
90035     } catch (...) {
90036       {
90037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90038       };
90039     }
90040   }
90041
90042   jresult = (void *)result;
90043   return jresult;
90044 }
90045
90046
90047 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanStartedSignal(void * jarg1) {
90048   void * jresult ;
90049   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
90050   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
90051
90052   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
90053   {
90054     try {
90055       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanStartedSignal();
90056     } catch (std::out_of_range& e) {
90057       {
90058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90059       };
90060     } catch (std::exception& e) {
90061       {
90062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90063       };
90064     } catch (Dali::DaliException e) {
90065       {
90066         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90067       };
90068     } catch (...) {
90069       {
90070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90071       };
90072     }
90073   }
90074
90075   jresult = (void *)result;
90076   return jresult;
90077 }
90078
90079
90080 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanFinishedSignal(void * jarg1) {
90081   void * jresult ;
90082   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
90083   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
90084
90085   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
90086   {
90087     try {
90088       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanFinishedSignal();
90089     } catch (std::out_of_range& e) {
90090       {
90091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90092       };
90093     } catch (std::exception& e) {
90094       {
90095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90096       };
90097     } catch (Dali::DaliException e) {
90098       {
90099         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90100       };
90101     } catch (...) {
90102       {
90103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90104       };
90105     }
90106   }
90107
90108   jresult = (void *)result;
90109   return jresult;
90110 }
90111
90112
90113 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_0() {
90114   void * jresult ;
90115   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
90116
90117   {
90118     try {
90119       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView();
90120     } catch (std::out_of_range& e) {
90121       {
90122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90123       };
90124     } catch (std::exception& e) {
90125       {
90126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90127       };
90128     } catch (Dali::DaliException e) {
90129       {
90130         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90131       };
90132     } catch (...) {
90133       {
90134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90135       };
90136     }
90137   }
90138
90139   jresult = (void *)result;
90140   return jresult;
90141 }
90142
90143
90144 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_1(void * jarg1) {
90145   void * jresult ;
90146   Dali::Toolkit::PageTurnLandscapeView *arg1 = 0 ;
90147   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
90148
90149   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
90150   if (!arg1) {
90151     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
90152     return 0;
90153   }
90154   {
90155     try {
90156       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView((Dali::Toolkit::PageTurnLandscapeView const &)*arg1);
90157     } catch (std::out_of_range& e) {
90158       {
90159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90160       };
90161     } catch (std::exception& e) {
90162       {
90163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90164       };
90165     } catch (Dali::DaliException e) {
90166       {
90167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90168       };
90169     } catch (...) {
90170       {
90171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90172       };
90173     }
90174   }
90175
90176   jresult = (void *)result;
90177   return jresult;
90178 }
90179
90180
90181 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_Assign(void * jarg1, void * jarg2) {
90182   void * jresult ;
90183   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
90184   Dali::Toolkit::PageTurnLandscapeView *arg2 = 0 ;
90185   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
90186
90187   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
90188   arg2 = (Dali::Toolkit::PageTurnLandscapeView *)jarg2;
90189   if (!arg2) {
90190     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
90191     return 0;
90192   }
90193   {
90194     try {
90195       result = (Dali::Toolkit::PageTurnLandscapeView *) &(arg1)->operator =((Dali::Toolkit::PageTurnLandscapeView const &)*arg2);
90196     } catch (std::out_of_range& e) {
90197       {
90198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90199       };
90200     } catch (std::exception& e) {
90201       {
90202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90203       };
90204     } catch (Dali::DaliException e) {
90205       {
90206         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90207       };
90208     } catch (...) {
90209       {
90210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90211       };
90212     }
90213   }
90214
90215   jresult = (void *)result;
90216   return jresult;
90217 }
90218
90219
90220 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnLandscapeView(void * jarg1) {
90221   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
90222
90223   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
90224   {
90225     try {
90226       delete arg1;
90227     } catch (std::out_of_range& e) {
90228       {
90229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90230       };
90231     } catch (std::exception& e) {
90232       {
90233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90234       };
90235     } catch (Dali::DaliException e) {
90236       {
90237         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90238       };
90239     } catch (...) {
90240       {
90241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90242       };
90243     }
90244   }
90245
90246 }
90247
90248
90249 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_New(void * jarg1, void * jarg2) {
90250   void * jresult ;
90251   Dali::Toolkit::PageFactory *arg1 = 0 ;
90252   Dali::Vector2 *arg2 = 0 ;
90253   Dali::Toolkit::PageTurnLandscapeView result;
90254
90255   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
90256   if (!arg1) {
90257     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
90258     return 0;
90259   }
90260   arg2 = (Dali::Vector2 *)jarg2;
90261   if (!arg2) {
90262     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
90263     return 0;
90264   }
90265   {
90266     try {
90267       result = Dali::Toolkit::PageTurnLandscapeView::New(*arg1,(Dali::Vector2 const &)*arg2);
90268     } catch (std::out_of_range& e) {
90269       {
90270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90271       };
90272     } catch (std::exception& e) {
90273       {
90274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90275       };
90276     } catch (Dali::DaliException e) {
90277       {
90278         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90279       };
90280     } catch (...) {
90281       {
90282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90283       };
90284     }
90285   }
90286
90287   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
90288   return jresult;
90289 }
90290
90291
90292 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_DownCast(void * jarg1) {
90293   void * jresult ;
90294   Dali::BaseHandle arg1 ;
90295   Dali::BaseHandle *argp1 ;
90296   Dali::Toolkit::PageTurnLandscapeView result;
90297
90298   argp1 = (Dali::BaseHandle *)jarg1;
90299   if (!argp1) {
90300     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
90301     return 0;
90302   }
90303   arg1 = *argp1;
90304   {
90305     try {
90306       result = Dali::Toolkit::PageTurnLandscapeView::DownCast(arg1);
90307     } catch (std::out_of_range& e) {
90308       {
90309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90310       };
90311     } catch (std::exception& e) {
90312       {
90313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90314       };
90315     } catch (Dali::DaliException e) {
90316       {
90317         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90318       };
90319     } catch (...) {
90320       {
90321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90322       };
90323     }
90324   }
90325
90326   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
90327   return jresult;
90328 }
90329
90330
90331 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_0() {
90332   void * jresult ;
90333   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
90334
90335   {
90336     try {
90337       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView();
90338     } catch (std::out_of_range& e) {
90339       {
90340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90341       };
90342     } catch (std::exception& e) {
90343       {
90344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90345       };
90346     } catch (Dali::DaliException e) {
90347       {
90348         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90349       };
90350     } catch (...) {
90351       {
90352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90353       };
90354     }
90355   }
90356
90357   jresult = (void *)result;
90358   return jresult;
90359 }
90360
90361
90362 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_1(void * jarg1) {
90363   void * jresult ;
90364   Dali::Toolkit::PageTurnPortraitView *arg1 = 0 ;
90365   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
90366
90367   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
90368   if (!arg1) {
90369     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
90370     return 0;
90371   }
90372   {
90373     try {
90374       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView((Dali::Toolkit::PageTurnPortraitView const &)*arg1);
90375     } catch (std::out_of_range& e) {
90376       {
90377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90378       };
90379     } catch (std::exception& e) {
90380       {
90381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90382       };
90383     } catch (Dali::DaliException e) {
90384       {
90385         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90386       };
90387     } catch (...) {
90388       {
90389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90390       };
90391     }
90392   }
90393
90394   jresult = (void *)result;
90395   return jresult;
90396 }
90397
90398
90399 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_Assign(void * jarg1, void * jarg2) {
90400   void * jresult ;
90401   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
90402   Dali::Toolkit::PageTurnPortraitView *arg2 = 0 ;
90403   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
90404
90405   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
90406   arg2 = (Dali::Toolkit::PageTurnPortraitView *)jarg2;
90407   if (!arg2) {
90408     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
90409     return 0;
90410   }
90411   {
90412     try {
90413       result = (Dali::Toolkit::PageTurnPortraitView *) &(arg1)->operator =((Dali::Toolkit::PageTurnPortraitView const &)*arg2);
90414     } catch (std::out_of_range& e) {
90415       {
90416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90417       };
90418     } catch (std::exception& e) {
90419       {
90420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90421       };
90422     } catch (Dali::DaliException e) {
90423       {
90424         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90425       };
90426     } catch (...) {
90427       {
90428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90429       };
90430     }
90431   }
90432
90433   jresult = (void *)result;
90434   return jresult;
90435 }
90436
90437
90438 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnPortraitView(void * jarg1) {
90439   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
90440
90441   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
90442   {
90443     try {
90444       delete arg1;
90445     } catch (std::out_of_range& e) {
90446       {
90447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90448       };
90449     } catch (std::exception& e) {
90450       {
90451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90452       };
90453     } catch (Dali::DaliException e) {
90454       {
90455         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90456       };
90457     } catch (...) {
90458       {
90459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90460       };
90461     }
90462   }
90463
90464 }
90465
90466
90467 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_New(void * jarg1, void * jarg2) {
90468   void * jresult ;
90469   Dali::Toolkit::PageFactory *arg1 = 0 ;
90470   Dali::Vector2 *arg2 = 0 ;
90471   Dali::Toolkit::PageTurnPortraitView result;
90472
90473   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
90474   if (!arg1) {
90475     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
90476     return 0;
90477   }
90478   arg2 = (Dali::Vector2 *)jarg2;
90479   if (!arg2) {
90480     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
90481     return 0;
90482   }
90483   {
90484     try {
90485       result = Dali::Toolkit::PageTurnPortraitView::New(*arg1,(Dali::Vector2 const &)*arg2);
90486     } catch (std::out_of_range& e) {
90487       {
90488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90489       };
90490     } catch (std::exception& e) {
90491       {
90492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90493       };
90494     } catch (Dali::DaliException e) {
90495       {
90496         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90497       };
90498     } catch (...) {
90499       {
90500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90501       };
90502     }
90503   }
90504
90505   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
90506   return jresult;
90507 }
90508
90509
90510 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_DownCast(void * jarg1) {
90511   void * jresult ;
90512   Dali::BaseHandle arg1 ;
90513   Dali::BaseHandle *argp1 ;
90514   Dali::Toolkit::PageTurnPortraitView result;
90515
90516   argp1 = (Dali::BaseHandle *)jarg1;
90517   if (!argp1) {
90518     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
90519     return 0;
90520   }
90521   arg1 = *argp1;
90522   {
90523     try {
90524       result = Dali::Toolkit::PageTurnPortraitView::DownCast(arg1);
90525     } catch (std::out_of_range& e) {
90526       {
90527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90528       };
90529     } catch (std::exception& e) {
90530       {
90531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90532       };
90533     } catch (Dali::DaliException e) {
90534       {
90535         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90536       };
90537     } catch (...) {
90538       {
90539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90540       };
90541     }
90542   }
90543
90544   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
90545   return jresult;
90546 }
90547
90548
90549 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_STATE_VISUALS_get() {
90550   int jresult ;
90551   int result;
90552
90553   result = (int)Dali::Toolkit::ToggleButton::Property::STATE_VISUALS;
90554   jresult = (int)result;
90555   return jresult;
90556 }
90557
90558
90559 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_TOOLTIPS_get() {
90560   int jresult ;
90561   int result;
90562
90563   result = (int)Dali::Toolkit::ToggleButton::Property::TOOLTIPS;
90564   jresult = (int)result;
90565   return jresult;
90566 }
90567
90568
90569 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_CURRENT_STATE_INDEX_get() {
90570   int jresult ;
90571   int result;
90572
90573   result = (int)Dali::Toolkit::ToggleButton::Property::CURRENT_STATE_INDEX;
90574   jresult = (int)result;
90575   return jresult;
90576 }
90577
90578
90579 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton_Property() {
90580   void * jresult ;
90581   Dali::Toolkit::ToggleButton::Property *result = 0 ;
90582
90583   {
90584     try {
90585       result = (Dali::Toolkit::ToggleButton::Property *)new Dali::Toolkit::ToggleButton::Property();
90586     } catch (std::out_of_range& e) {
90587       {
90588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90589       };
90590     } catch (std::exception& e) {
90591       {
90592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90593       };
90594     } catch (Dali::DaliException e) {
90595       {
90596         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90597       };
90598     } catch (...) {
90599       {
90600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90601       };
90602     }
90603   }
90604
90605   jresult = (void *)result;
90606   return jresult;
90607 }
90608
90609
90610 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton_Property(void * jarg1) {
90611   Dali::Toolkit::ToggleButton::Property *arg1 = (Dali::Toolkit::ToggleButton::Property *) 0 ;
90612
90613   arg1 = (Dali::Toolkit::ToggleButton::Property *)jarg1;
90614   {
90615     try {
90616       delete arg1;
90617     } catch (std::out_of_range& e) {
90618       {
90619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90620       };
90621     } catch (std::exception& e) {
90622       {
90623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90624       };
90625     } catch (Dali::DaliException e) {
90626       {
90627         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90628       };
90629     } catch (...) {
90630       {
90631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90632       };
90633     }
90634   }
90635
90636 }
90637
90638
90639 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_0() {
90640   void * jresult ;
90641   Dali::Toolkit::ToggleButton *result = 0 ;
90642
90643   {
90644     try {
90645       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton();
90646     } catch (std::out_of_range& e) {
90647       {
90648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90649       };
90650     } catch (std::exception& e) {
90651       {
90652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90653       };
90654     } catch (Dali::DaliException e) {
90655       {
90656         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90657       };
90658     } catch (...) {
90659       {
90660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90661       };
90662     }
90663   }
90664
90665   jresult = (void *)result;
90666   return jresult;
90667 }
90668
90669
90670 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_1(void * jarg1) {
90671   void * jresult ;
90672   Dali::Toolkit::ToggleButton *arg1 = 0 ;
90673   Dali::Toolkit::ToggleButton *result = 0 ;
90674
90675   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
90676   if (!arg1) {
90677     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
90678     return 0;
90679   }
90680   {
90681     try {
90682       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton((Dali::Toolkit::ToggleButton const &)*arg1);
90683     } catch (std::out_of_range& e) {
90684       {
90685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90686       };
90687     } catch (std::exception& e) {
90688       {
90689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90690       };
90691     } catch (Dali::DaliException e) {
90692       {
90693         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90694       };
90695     } catch (...) {
90696       {
90697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90698       };
90699     }
90700   }
90701
90702   jresult = (void *)result;
90703   return jresult;
90704 }
90705
90706
90707 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_Assign(void * jarg1, void * jarg2) {
90708   void * jresult ;
90709   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
90710   Dali::Toolkit::ToggleButton *arg2 = 0 ;
90711   Dali::Toolkit::ToggleButton *result = 0 ;
90712
90713   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
90714   arg2 = (Dali::Toolkit::ToggleButton *)jarg2;
90715   if (!arg2) {
90716     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
90717     return 0;
90718   }
90719   {
90720     try {
90721       result = (Dali::Toolkit::ToggleButton *) &(arg1)->operator =((Dali::Toolkit::ToggleButton const &)*arg2);
90722     } catch (std::out_of_range& e) {
90723       {
90724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90725       };
90726     } catch (std::exception& e) {
90727       {
90728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90729       };
90730     } catch (Dali::DaliException e) {
90731       {
90732         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90733       };
90734     } catch (...) {
90735       {
90736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90737       };
90738     }
90739   }
90740
90741   jresult = (void *)result;
90742   return jresult;
90743 }
90744
90745
90746 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton(void * jarg1) {
90747   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
90748
90749   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
90750   {
90751     try {
90752       delete arg1;
90753     } catch (std::out_of_range& e) {
90754       {
90755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90756       };
90757     } catch (std::exception& e) {
90758       {
90759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90760       };
90761     } catch (Dali::DaliException e) {
90762       {
90763         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90764       };
90765     } catch (...) {
90766       {
90767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90768       };
90769     }
90770   }
90771
90772 }
90773
90774
90775 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_New() {
90776   void * jresult ;
90777   Dali::Toolkit::ToggleButton result;
90778
90779   {
90780     try {
90781       result = Dali::Toolkit::ToggleButton::New();
90782     } catch (std::out_of_range& e) {
90783       {
90784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90785       };
90786     } catch (std::exception& e) {
90787       {
90788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90789       };
90790     } catch (Dali::DaliException e) {
90791       {
90792         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90793       };
90794     } catch (...) {
90795       {
90796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90797       };
90798     }
90799   }
90800
90801   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
90802   return jresult;
90803 }
90804
90805
90806 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_DownCast(void * jarg1) {
90807   void * jresult ;
90808   Dali::BaseHandle arg1 ;
90809   Dali::BaseHandle *argp1 ;
90810   Dali::Toolkit::ToggleButton result;
90811
90812   argp1 = (Dali::BaseHandle *)jarg1;
90813   if (!argp1) {
90814     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
90815     return 0;
90816   }
90817   arg1 = *argp1;
90818   {
90819     try {
90820       result = Dali::Toolkit::ToggleButton::DownCast(arg1);
90821     } catch (std::out_of_range& e) {
90822       {
90823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90824       };
90825     } catch (std::exception& e) {
90826       {
90827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90828       };
90829     } catch (Dali::DaliException e) {
90830       {
90831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90832       };
90833     } catch (...) {
90834       {
90835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90836       };
90837     }
90838   }
90839
90840   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
90841   return jresult;
90842 }
90843
90844
90845 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_0() {
90846   void * jresult ;
90847   Dali::Toolkit::Visual::Base *result = 0 ;
90848
90849   {
90850     try {
90851       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base();
90852     } catch (std::out_of_range& e) {
90853       {
90854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90855       };
90856     } catch (std::exception& e) {
90857       {
90858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90859       };
90860     } catch (Dali::DaliException e) {
90861       {
90862         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90863       };
90864     } catch (...) {
90865       {
90866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90867       };
90868     }
90869   }
90870
90871   jresult = (void *)result;
90872   return jresult;
90873 }
90874
90875
90876 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualBase(void * jarg1) {
90877   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
90878
90879   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90880   {
90881     try {
90882       delete arg1;
90883     } catch (std::out_of_range& e) {
90884       {
90885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90886       };
90887     } catch (std::exception& e) {
90888       {
90889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90890       };
90891     } catch (Dali::DaliException e) {
90892       {
90893         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90894       };
90895     } catch (...) {
90896       {
90897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90898       };
90899     }
90900   }
90901
90902 }
90903
90904
90905 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_1(void * jarg1) {
90906   void * jresult ;
90907   Dali::Toolkit::Visual::Base *arg1 = 0 ;
90908   Dali::Toolkit::Visual::Base *result = 0 ;
90909
90910   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90911   if (!arg1) {
90912     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
90913     return 0;
90914   }
90915   {
90916     try {
90917       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base((Dali::Toolkit::Visual::Base const &)*arg1);
90918     } catch (std::out_of_range& e) {
90919       {
90920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90921       };
90922     } catch (std::exception& e) {
90923       {
90924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90925       };
90926     } catch (Dali::DaliException e) {
90927       {
90928         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90929       };
90930     } catch (...) {
90931       {
90932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90933       };
90934     }
90935   }
90936
90937   jresult = (void *)result;
90938   return jresult;
90939 }
90940
90941
90942 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualBase_Assign(void * jarg1, void * jarg2) {
90943   void * jresult ;
90944   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
90945   Dali::Toolkit::Visual::Base *arg2 = 0 ;
90946   Dali::Toolkit::Visual::Base *result = 0 ;
90947
90948   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90949   arg2 = (Dali::Toolkit::Visual::Base *)jarg2;
90950   if (!arg2) {
90951     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
90952     return 0;
90953   }
90954   {
90955     try {
90956       result = (Dali::Toolkit::Visual::Base *) &(arg1)->operator =((Dali::Toolkit::Visual::Base const &)*arg2);
90957     } catch (std::out_of_range& e) {
90958       {
90959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90960       };
90961     } catch (std::exception& e) {
90962       {
90963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90964       };
90965     } catch (Dali::DaliException e) {
90966       {
90967         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90968       };
90969     } catch (...) {
90970       {
90971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90972       };
90973     }
90974   }
90975
90976   jresult = (void *)result;
90977   return jresult;
90978 }
90979
90980
90981 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetName(void * jarg1, char * jarg2) {
90982   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
90983   std::string *arg2 = 0 ;
90984
90985   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90986   if (!jarg2) {
90987     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
90988     return ;
90989   }
90990   std::string arg2_str(jarg2);
90991   arg2 = &arg2_str;
90992   {
90993     try {
90994       (arg1)->SetName((std::string const &)*arg2);
90995     } catch (std::out_of_range& e) {
90996       {
90997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90998       };
90999     } catch (std::exception& e) {
91000       {
91001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91002       };
91003     } catch (Dali::DaliException e) {
91004       {
91005         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91006       };
91007     } catch (...) {
91008       {
91009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91010       };
91011     }
91012   }
91013
91014
91015   //argout typemap for const std::string&
91016
91017 }
91018
91019
91020 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_VisualBase_GetName(void * jarg1) {
91021   char * jresult ;
91022   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91023   std::string *result = 0 ;
91024
91025   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91026   {
91027     try {
91028       result = (std::string *) &(arg1)->GetName();
91029     } catch (std::out_of_range& e) {
91030       {
91031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91032       };
91033     } catch (std::exception& e) {
91034       {
91035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91036       };
91037     } catch (Dali::DaliException e) {
91038       {
91039         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91040       };
91041     } catch (...) {
91042       {
91043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91044       };
91045     }
91046   }
91047
91048   jresult = SWIG_csharp_string_callback(result->c_str());
91049   return jresult;
91050 }
91051
91052
91053 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetTransformAndSize(void * jarg1, void * jarg2, void * jarg3) {
91054   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91055   Dali::Property::Map *arg2 = 0 ;
91056   Dali::Size arg3 ;
91057   Dali::Size *argp3 ;
91058
91059   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91060   arg2 = (Dali::Property::Map *)jarg2;
91061   if (!arg2) {
91062     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
91063     return ;
91064   }
91065   argp3 = (Dali::Size *)jarg3;
91066   if (!argp3) {
91067     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
91068     return ;
91069   }
91070   arg3 = *argp3;
91071   {
91072     try {
91073       (arg1)->SetTransformAndSize((Dali::Property::Map const &)*arg2,arg3);
91074     } catch (std::out_of_range& e) {
91075       {
91076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91077       };
91078     } catch (std::exception& e) {
91079       {
91080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91081       };
91082     } catch (Dali::DaliException e) {
91083       {
91084         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91085       };
91086     } catch (...) {
91087       {
91088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91089       };
91090     }
91091   }
91092
91093 }
91094
91095
91096 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetHeightForWidth(void * jarg1, float jarg2) {
91097   float jresult ;
91098   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91099   float arg2 ;
91100   float result;
91101
91102   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91103   arg2 = (float)jarg2;
91104   {
91105     try {
91106       result = (float)(arg1)->GetHeightForWidth(arg2);
91107     } catch (std::out_of_range& e) {
91108       {
91109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91110       };
91111     } catch (std::exception& e) {
91112       {
91113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91114       };
91115     } catch (Dali::DaliException e) {
91116       {
91117         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91118       };
91119     } catch (...) {
91120       {
91121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91122       };
91123     }
91124   }
91125
91126   jresult = result;
91127   return jresult;
91128 }
91129
91130
91131 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetWidthForHeight(void * jarg1, float jarg2) {
91132   float jresult ;
91133   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91134   float arg2 ;
91135   float result;
91136
91137   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91138   arg2 = (float)jarg2;
91139   {
91140     try {
91141       result = (float)(arg1)->GetWidthForHeight(arg2);
91142     } catch (std::out_of_range& e) {
91143       {
91144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91145       };
91146     } catch (std::exception& e) {
91147       {
91148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91149       };
91150     } catch (Dali::DaliException e) {
91151       {
91152         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91153       };
91154     } catch (...) {
91155       {
91156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91157       };
91158     }
91159   }
91160
91161   jresult = result;
91162   return jresult;
91163 }
91164
91165
91166 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_GetNaturalSize(void * jarg1, void * jarg2) {
91167   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91168   Dali::Vector2 *arg2 = 0 ;
91169
91170   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91171   arg2 = (Dali::Vector2 *)jarg2;
91172   if (!arg2) {
91173     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
91174     return ;
91175   }
91176   {
91177     try {
91178       (arg1)->GetNaturalSize(*arg2);
91179     } catch (std::out_of_range& e) {
91180       {
91181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91182       };
91183     } catch (std::exception& e) {
91184       {
91185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91186       };
91187     } catch (Dali::DaliException e) {
91188       {
91189         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91190       };
91191     } catch (...) {
91192       {
91193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91194       };
91195     }
91196   }
91197
91198 }
91199
91200
91201 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetDepthIndex(void * jarg1, int jarg2) {
91202   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91203   float arg2 ;
91204
91205   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91206   arg2 = (int)jarg2;
91207   {
91208     try {
91209       (arg1)->SetDepthIndex(arg2);
91210     } catch (std::out_of_range& e) {
91211       {
91212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91213       };
91214     } catch (std::exception& e) {
91215       {
91216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91217       };
91218     } catch (Dali::DaliException e) {
91219       {
91220         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91221       };
91222     } catch (...) {
91223       {
91224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91225       };
91226     }
91227   }
91228
91229 }
91230
91231
91232 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VisualBase_GetDepthIndex(void * jarg1) {
91233   int jresult ;
91234   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91235   int result;
91236
91237   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91238   {
91239     try {
91240       result = (float)((Dali::Toolkit::Visual::Base const *)arg1)->GetDepthIndex();
91241     } catch (std::out_of_range& e) {
91242       {
91243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91244       };
91245     } catch (std::exception& e) {
91246       {
91247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91248       };
91249     } catch (Dali::DaliException e) {
91250       {
91251         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91252       };
91253     } catch (...) {
91254       {
91255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91256       };
91257     }
91258   }
91259
91260   jresult = result;
91261   return jresult;
91262 }
91263
91264
91265 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_CreatePropertyMap(void * jarg1, void * jarg2) {
91266   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91267   Dali::Property::Map *arg2 = 0 ;
91268
91269   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91270   arg2 = (Dali::Property::Map *)jarg2;
91271   if (!arg2) {
91272     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
91273     return ;
91274   }
91275   {
91276     try {
91277       ((Dali::Toolkit::Visual::Base const *)arg1)->CreatePropertyMap(*arg2);
91278     } catch (std::out_of_range& e) {
91279       {
91280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91281       };
91282     } catch (std::exception& e) {
91283       {
91284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91285       };
91286     } catch (Dali::DaliException e) {
91287       {
91288         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91289       };
91290     } catch (...) {
91291       {
91292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91293       };
91294     }
91295   }
91296
91297 }
91298
91299
91300 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Get() {
91301   void * jresult ;
91302   Dali::Toolkit::VisualFactory result;
91303
91304   {
91305     try {
91306       result = Dali::Toolkit::VisualFactory::Get();
91307     } catch (std::out_of_range& e) {
91308       {
91309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91310       };
91311     } catch (std::exception& e) {
91312       {
91313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91314       };
91315     } catch (Dali::DaliException e) {
91316       {
91317         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91318       };
91319     } catch (...) {
91320       {
91321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91322       };
91323     }
91324   }
91325
91326   jresult = new Dali::Toolkit::VisualFactory((const Dali::Toolkit::VisualFactory &)result);
91327   return jresult;
91328 }
91329
91330
91331 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_0() {
91332   void * jresult ;
91333   Dali::Toolkit::VisualFactory *result = 0 ;
91334
91335   {
91336     try {
91337       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory();
91338     } catch (std::out_of_range& e) {
91339       {
91340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91341       };
91342     } catch (std::exception& e) {
91343       {
91344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91345       };
91346     } catch (Dali::DaliException e) {
91347       {
91348         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91349       };
91350     } catch (...) {
91351       {
91352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91353       };
91354     }
91355   }
91356
91357   jresult = (void *)result;
91358   return jresult;
91359 }
91360
91361
91362 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualFactory(void * jarg1) {
91363   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
91364
91365   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91366   {
91367     try {
91368       delete arg1;
91369     } catch (std::out_of_range& e) {
91370       {
91371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91372       };
91373     } catch (std::exception& e) {
91374       {
91375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91376       };
91377     } catch (Dali::DaliException e) {
91378       {
91379         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91380       };
91381     } catch (...) {
91382       {
91383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91384       };
91385     }
91386   }
91387
91388 }
91389
91390
91391 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_1(void * jarg1) {
91392   void * jresult ;
91393   Dali::Toolkit::VisualFactory *arg1 = 0 ;
91394   Dali::Toolkit::VisualFactory *result = 0 ;
91395
91396   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91397   if (!arg1) {
91398     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
91399     return 0;
91400   }
91401   {
91402     try {
91403       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory((Dali::Toolkit::VisualFactory const &)*arg1);
91404     } catch (std::out_of_range& e) {
91405       {
91406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91407       };
91408     } catch (std::exception& e) {
91409       {
91410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91411       };
91412     } catch (Dali::DaliException e) {
91413       {
91414         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91415       };
91416     } catch (...) {
91417       {
91418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91419       };
91420     }
91421   }
91422
91423   jresult = (void *)result;
91424   return jresult;
91425 }
91426
91427
91428 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Assign(void * jarg1, void * jarg2) {
91429   void * jresult ;
91430   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
91431   Dali::Toolkit::VisualFactory *arg2 = 0 ;
91432   Dali::Toolkit::VisualFactory *result = 0 ;
91433
91434   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91435   arg2 = (Dali::Toolkit::VisualFactory *)jarg2;
91436   if (!arg2) {
91437     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
91438     return 0;
91439   }
91440   {
91441     try {
91442       result = (Dali::Toolkit::VisualFactory *) &(arg1)->operator =((Dali::Toolkit::VisualFactory const &)*arg2);
91443     } catch (std::out_of_range& e) {
91444       {
91445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91446       };
91447     } catch (std::exception& e) {
91448       {
91449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91450       };
91451     } catch (Dali::DaliException e) {
91452       {
91453         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91454       };
91455     } catch (...) {
91456       {
91457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91458       };
91459     }
91460   }
91461
91462   jresult = (void *)result;
91463   return jresult;
91464 }
91465
91466
91467 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_0(void * jarg1, void * jarg2) {
91468   void * jresult ;
91469   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
91470   Dali::Property::Map *arg2 = 0 ;
91471   Dali::Toolkit::Visual::Base result;
91472
91473   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91474   arg2 = (Dali::Property::Map *)jarg2;
91475   if (!arg2) {
91476     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
91477     return 0;
91478   }
91479   {
91480     try {
91481       result = (arg1)->CreateVisual((Dali::Property::Map const &)*arg2);
91482     } catch (std::out_of_range& e) {
91483       {
91484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91485       };
91486     } catch (std::exception& e) {
91487       {
91488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91489       };
91490     } catch (Dali::DaliException e) {
91491       {
91492         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91493       };
91494     } catch (...) {
91495       {
91496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91497       };
91498     }
91499   }
91500
91501   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
91502   return jresult;
91503 }
91504
91505
91506 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_1(void * jarg1, void * jarg2) {
91507   void * jresult ;
91508   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
91509   Dali::Image *arg2 = 0 ;
91510   Dali::Toolkit::Visual::Base result;
91511
91512   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91513   arg2 = (Dali::Image *)jarg2;
91514   if (!arg2) {
91515     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
91516     return 0;
91517   }
91518   {
91519     try {
91520       result = (arg1)->CreateVisual((Dali::Image const &)*arg2);
91521     } catch (std::out_of_range& e) {
91522       {
91523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91524       };
91525     } catch (std::exception& e) {
91526       {
91527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91528       };
91529     } catch (Dali::DaliException e) {
91530       {
91531         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91532       };
91533     } catch (...) {
91534       {
91535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91536       };
91537     }
91538   }
91539
91540   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
91541   return jresult;
91542 }
91543
91544
91545 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
91546   void * jresult ;
91547   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
91548   std::string *arg2 = 0 ;
91549   Dali::ImageDimensions arg3 ;
91550   Dali::ImageDimensions *argp3 ;
91551   Dali::Toolkit::Visual::Base result;
91552
91553   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91554   if (!jarg2) {
91555     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
91556     return 0;
91557   }
91558   std::string arg2_str(jarg2);
91559   arg2 = &arg2_str;
91560   argp3 = (Dali::ImageDimensions *)jarg3;
91561   if (!argp3) {
91562     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
91563     return 0;
91564   }
91565   arg3 = *argp3;
91566   {
91567     try {
91568       result = (arg1)->CreateVisual((std::string const &)*arg2,arg3);
91569     } catch (std::out_of_range& e) {
91570       {
91571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91572       };
91573     } catch (std::exception& e) {
91574       {
91575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91576       };
91577     } catch (Dali::DaliException e) {
91578       {
91579         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91580       };
91581     } catch (...) {
91582       {
91583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91584       };
91585     }
91586   }
91587
91588   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
91589
91590   //argout typemap for const std::string&
91591
91592   return jresult;
91593 }
91594
91595
91596 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_0() {
91597   void * jresult ;
91598   Dali::Toolkit::AsyncImageLoader *result = 0 ;
91599
91600   {
91601     try {
91602       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader();
91603     } catch (std::out_of_range& e) {
91604       {
91605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91606       };
91607     } catch (std::exception& e) {
91608       {
91609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91610       };
91611     } catch (Dali::DaliException e) {
91612       {
91613         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91614       };
91615     } catch (...) {
91616       {
91617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91618       };
91619     }
91620   }
91621
91622   jresult = (void *)result;
91623   return jresult;
91624 }
91625
91626
91627 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AsyncImageLoader(void * jarg1) {
91628   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
91629
91630   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
91631   {
91632     try {
91633       delete arg1;
91634     } catch (std::out_of_range& e) {
91635       {
91636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91637       };
91638     } catch (std::exception& e) {
91639       {
91640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91641       };
91642     } catch (Dali::DaliException e) {
91643       {
91644         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91645       };
91646     } catch (...) {
91647       {
91648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91649       };
91650     }
91651   }
91652
91653 }
91654
91655
91656 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_1(void * jarg1) {
91657   void * jresult ;
91658   Dali::Toolkit::AsyncImageLoader *arg1 = 0 ;
91659   Dali::Toolkit::AsyncImageLoader *result = 0 ;
91660
91661   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
91662   if (!arg1) {
91663     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
91664     return 0;
91665   }
91666   {
91667     try {
91668       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader((Dali::Toolkit::AsyncImageLoader const &)*arg1);
91669     } catch (std::out_of_range& e) {
91670       {
91671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91672       };
91673     } catch (std::exception& e) {
91674       {
91675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91676       };
91677     } catch (Dali::DaliException e) {
91678       {
91679         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91680       };
91681     } catch (...) {
91682       {
91683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91684       };
91685     }
91686   }
91687
91688   jresult = (void *)result;
91689   return jresult;
91690 }
91691
91692
91693 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Assign(void * jarg1, void * jarg2) {
91694   void * jresult ;
91695   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
91696   Dali::Toolkit::AsyncImageLoader *arg2 = 0 ;
91697   Dali::Toolkit::AsyncImageLoader *result = 0 ;
91698
91699   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
91700   arg2 = (Dali::Toolkit::AsyncImageLoader *)jarg2;
91701   if (!arg2) {
91702     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
91703     return 0;
91704   }
91705   {
91706     try {
91707       result = (Dali::Toolkit::AsyncImageLoader *) &(arg1)->operator =((Dali::Toolkit::AsyncImageLoader const &)*arg2);
91708     } catch (std::out_of_range& e) {
91709       {
91710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91711       };
91712     } catch (std::exception& e) {
91713       {
91714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91715       };
91716     } catch (Dali::DaliException e) {
91717       {
91718         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91719       };
91720     } catch (...) {
91721       {
91722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91723       };
91724     }
91725   }
91726
91727   jresult = (void *)result;
91728   return jresult;
91729 }
91730
91731
91732 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_New() {
91733   void * jresult ;
91734   Dali::Toolkit::AsyncImageLoader result;
91735
91736   {
91737     try {
91738       result = Dali::Toolkit::AsyncImageLoader::New();
91739     } catch (std::out_of_range& e) {
91740       {
91741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91742       };
91743     } catch (std::exception& e) {
91744       {
91745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91746       };
91747     } catch (Dali::DaliException e) {
91748       {
91749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91750       };
91751     } catch (...) {
91752       {
91753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91754       };
91755     }
91756   }
91757
91758   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
91759   return jresult;
91760 }
91761
91762
91763 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_DownCast(void * jarg1) {
91764   void * jresult ;
91765   Dali::BaseHandle arg1 ;
91766   Dali::BaseHandle *argp1 ;
91767   Dali::Toolkit::AsyncImageLoader result;
91768
91769   argp1 = (Dali::BaseHandle *)jarg1;
91770   if (!argp1) {
91771     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
91772     return 0;
91773   }
91774   arg1 = *argp1;
91775   {
91776     try {
91777       result = Dali::Toolkit::AsyncImageLoader::DownCast(arg1);
91778     } catch (std::out_of_range& e) {
91779       {
91780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91781       };
91782     } catch (std::exception& e) {
91783       {
91784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91785       };
91786     } catch (Dali::DaliException e) {
91787       {
91788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91789       };
91790     } catch (...) {
91791       {
91792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91793       };
91794     }
91795   }
91796
91797   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
91798   return jresult;
91799 }
91800
91801
91802 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_0(void * jarg1, char * jarg2) {
91803   unsigned int jresult ;
91804   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
91805   std::string *arg2 = 0 ;
91806   uint32_t result;
91807
91808   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
91809   if (!jarg2) {
91810     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
91811     return 0;
91812   }
91813   std::string arg2_str(jarg2);
91814   arg2 = &arg2_str;
91815   {
91816     try {
91817       result = (arg1)->Load((std::string const &)*arg2);
91818     } catch (std::out_of_range& e) {
91819       {
91820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91821       };
91822     } catch (std::exception& e) {
91823       {
91824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91825       };
91826     } catch (Dali::DaliException e) {
91827       {
91828         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91829       };
91830     } catch (...) {
91831       {
91832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91833       };
91834     }
91835   }
91836
91837   jresult = result;
91838
91839   //argout typemap for const std::string&
91840
91841   return jresult;
91842 }
91843
91844
91845 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
91846   unsigned int jresult ;
91847   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
91848   std::string *arg2 = 0 ;
91849   Dali::ImageDimensions arg3 ;
91850   Dali::ImageDimensions *argp3 ;
91851   uint32_t result;
91852
91853   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
91854   if (!jarg2) {
91855     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
91856     return 0;
91857   }
91858   std::string arg2_str(jarg2);
91859   arg2 = &arg2_str;
91860   argp3 = (Dali::ImageDimensions *)jarg3;
91861   if (!argp3) {
91862     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
91863     return 0;
91864   }
91865   arg3 = *argp3;
91866   {
91867     try {
91868       result = (arg1)->Load((std::string const &)*arg2,arg3);
91869     } catch (std::out_of_range& e) {
91870       {
91871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91872       };
91873     } catch (std::exception& e) {
91874       {
91875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91876       };
91877     } catch (Dali::DaliException e) {
91878       {
91879         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91880       };
91881     } catch (...) {
91882       {
91883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91884       };
91885     }
91886   }
91887
91888   jresult = result;
91889
91890   //argout typemap for const std::string&
91891
91892   return jresult;
91893 }
91894
91895
91896 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_2(void * jarg1, char * jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
91897   unsigned int jresult ;
91898   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
91899   std::string *arg2 = 0 ;
91900   Dali::ImageDimensions arg3 ;
91901   Dali::FittingMode::Type arg4 ;
91902   Dali::SamplingMode::Type arg5 ;
91903   bool arg6 ;
91904   Dali::ImageDimensions *argp3 ;
91905   uint32_t result;
91906
91907   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
91908   if (!jarg2) {
91909     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
91910     return 0;
91911   }
91912   std::string arg2_str(jarg2);
91913   arg2 = &arg2_str;
91914   argp3 = (Dali::ImageDimensions *)jarg3;
91915   if (!argp3) {
91916     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
91917     return 0;
91918   }
91919   arg3 = *argp3;
91920   arg4 = (Dali::FittingMode::Type)jarg4;
91921   arg5 = (Dali::SamplingMode::Type)jarg5;
91922   arg6 = jarg6 ? true : false;
91923   {
91924     try {
91925       result = (arg1)->Load((std::string const &)*arg2,arg3,arg4,arg5,arg6);
91926     } catch (std::out_of_range& e) {
91927       {
91928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91929       };
91930     } catch (std::exception& e) {
91931       {
91932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91933       };
91934     } catch (Dali::DaliException e) {
91935       {
91936         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91937       };
91938     } catch (...) {
91939       {
91940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91941       };
91942     }
91943   }
91944
91945   jresult = result;
91946
91947   //argout typemap for const std::string&
91948
91949   return jresult;
91950 }
91951
91952
91953 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Cancel(void * jarg1, unsigned int jarg2) {
91954   unsigned int jresult ;
91955   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
91956   uint32_t arg2 ;
91957   bool result;
91958
91959   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
91960   arg2 = (uint32_t)jarg2;
91961   {
91962     try {
91963       result = (bool)(arg1)->Cancel(arg2);
91964     } catch (std::out_of_range& e) {
91965       {
91966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91967       };
91968     } catch (std::exception& e) {
91969       {
91970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91971       };
91972     } catch (Dali::DaliException e) {
91973       {
91974         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91975       };
91976     } catch (...) {
91977       {
91978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91979       };
91980     }
91981   }
91982
91983   jresult = result;
91984   return jresult;
91985 }
91986
91987
91988 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AsyncImageLoader_CancelAll(void * jarg1) {
91989   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
91990
91991   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
91992   {
91993     try {
91994       (arg1)->CancelAll();
91995     } catch (std::out_of_range& e) {
91996       {
91997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91998       };
91999     } catch (std::exception& e) {
92000       {
92001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92002       };
92003     } catch (Dali::DaliException e) {
92004       {
92005         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92006       };
92007     } catch (...) {
92008       {
92009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92010       };
92011     }
92012   }
92013
92014 }
92015
92016
92017 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_ImageLoadedSignal(void * jarg1) {
92018   void * jresult ;
92019   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
92020   Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *result = 0 ;
92021
92022   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92023   {
92024     try {
92025       result = (Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *) &(arg1)->ImageLoadedSignal();
92026     } catch (std::out_of_range& e) {
92027       {
92028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92029       };
92030     } catch (std::exception& e) {
92031       {
92032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92033       };
92034     } catch (Dali::DaliException e) {
92035       {
92036         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92037       };
92038     } catch (...) {
92039       {
92040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92041       };
92042     }
92043   }
92044
92045   jresult = (void *)result;
92046   return jresult;
92047 }
92048
92049
92050 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_0(char * jarg1) {
92051   void * jresult ;
92052   std::string *arg1 = 0 ;
92053   Dali::PixelData result;
92054
92055   if (!jarg1) {
92056     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
92057     return 0;
92058   }
92059   std::string arg1_str(jarg1);
92060   arg1 = &arg1_str;
92061   {
92062     try {
92063       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1);
92064     } catch (std::out_of_range& e) {
92065       {
92066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92067       };
92068     } catch (std::exception& e) {
92069       {
92070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92071       };
92072     } catch (Dali::DaliException e) {
92073       {
92074         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92075       };
92076     } catch (...) {
92077       {
92078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92079       };
92080     }
92081   }
92082
92083   jresult = new Dali::PixelData((const Dali::PixelData &)result);
92084
92085   //argout typemap for const std::string&
92086
92087   return jresult;
92088 }
92089
92090
92091 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_1(char * jarg1, void * jarg2) {
92092   void * jresult ;
92093   std::string *arg1 = 0 ;
92094   Dali::ImageDimensions arg2 ;
92095   Dali::ImageDimensions *argp2 ;
92096   Dali::PixelData result;
92097
92098   if (!jarg1) {
92099     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
92100     return 0;
92101   }
92102   std::string arg1_str(jarg1);
92103   arg1 = &arg1_str;
92104   argp2 = (Dali::ImageDimensions *)jarg2;
92105   if (!argp2) {
92106     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
92107     return 0;
92108   }
92109   arg2 = *argp2;
92110   {
92111     try {
92112       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2);
92113     } catch (std::out_of_range& e) {
92114       {
92115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92116       };
92117     } catch (std::exception& e) {
92118       {
92119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92120       };
92121     } catch (Dali::DaliException e) {
92122       {
92123         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92124       };
92125     } catch (...) {
92126       {
92127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92128       };
92129     }
92130   }
92131
92132   jresult = new Dali::PixelData((const Dali::PixelData &)result);
92133
92134   //argout typemap for const std::string&
92135
92136   return jresult;
92137 }
92138
92139
92140 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
92141   void * jresult ;
92142   std::string *arg1 = 0 ;
92143   Dali::ImageDimensions arg2 ;
92144   Dali::FittingMode::Type arg3 ;
92145   Dali::SamplingMode::Type arg4 ;
92146   bool arg5 ;
92147   Dali::ImageDimensions *argp2 ;
92148   Dali::PixelData result;
92149
92150   if (!jarg1) {
92151     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
92152     return 0;
92153   }
92154   std::string arg1_str(jarg1);
92155   arg1 = &arg1_str;
92156   argp2 = (Dali::ImageDimensions *)jarg2;
92157   if (!argp2) {
92158     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
92159     return 0;
92160   }
92161   arg2 = *argp2;
92162   arg3 = (Dali::FittingMode::Type)jarg3;
92163   arg4 = (Dali::SamplingMode::Type)jarg4;
92164   arg5 = jarg5 ? true : false;
92165   {
92166     try {
92167       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2,arg3,arg4,arg5);
92168     } catch (std::out_of_range& e) {
92169       {
92170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92171       };
92172     } catch (std::exception& e) {
92173       {
92174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92175       };
92176     } catch (Dali::DaliException e) {
92177       {
92178         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92179       };
92180     } catch (...) {
92181       {
92182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92183       };
92184     }
92185   }
92186
92187   jresult = new Dali::PixelData((const Dali::PixelData &)result);
92188
92189   //argout typemap for const std::string&
92190
92191   return jresult;
92192 }
92193
92194
92195 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomAlgorithmInterface(void * jarg1) {
92196   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
92197
92198   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
92199   {
92200     try {
92201       delete arg1;
92202     } catch (std::out_of_range& e) {
92203       {
92204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92205       };
92206     } catch (std::exception& e) {
92207       {
92208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92209       };
92210     } catch (Dali::DaliException e) {
92211       {
92212         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92213       };
92214     } catch (...) {
92215       {
92216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92217       };
92218     }
92219   }
92220
92221 }
92222
92223
92224 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_GetNextFocusableActor(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
92225   void * jresult ;
92226   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
92227   Dali::Actor arg2 ;
92228   Dali::Actor arg3 ;
92229   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
92230   Dali::Actor *argp2 ;
92231   Dali::Actor *argp3 ;
92232   Dali::Actor result;
92233
92234   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
92235   argp2 = (Dali::Actor *)jarg2;
92236   if (!argp2) {
92237     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
92238     return 0;
92239   }
92240   arg2 = *argp2;
92241   argp3 = (Dali::Actor *)jarg3;
92242   if (!argp3) {
92243     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
92244     return 0;
92245   }
92246   arg3 = *argp3;
92247   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
92248   {
92249     try {
92250       result = (arg1)->GetNextFocusableActor(arg2,arg3,arg4);
92251     } catch (std::out_of_range& e) {
92252       {
92253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92254       };
92255     } catch (std::exception& e) {
92256       {
92257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92258       };
92259     } catch (Dali::DaliException e) {
92260       {
92261         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92262       };
92263     } catch (...) {
92264       {
92265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92266       };
92267     }
92268   }
92269
92270   jresult = new Dali::Actor((const Dali::Actor &)result);
92271   return jresult;
92272 }
92273
92274
92275 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomAlgorithmInterface() {
92276   void * jresult ;
92277   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *result = 0 ;
92278
92279   {
92280     try {
92281       result = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)new SwigDirector_CustomAlgorithmInterface();
92282     } catch (std::out_of_range& e) {
92283       {
92284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92285       };
92286     } catch (std::exception& e) {
92287       {
92288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92289       };
92290     } catch (Dali::DaliException e) {
92291       {
92292         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92293       };
92294     } catch (...) {
92295       {
92296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92297       };
92298     }
92299   }
92300
92301   jresult = (void *)result;
92302   return jresult;
92303 }
92304
92305
92306 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_director_connect(void *objarg, SwigDirector_CustomAlgorithmInterface::SWIG_Callback0_t callback0) {
92307   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *obj = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)objarg;
92308   SwigDirector_CustomAlgorithmInterface *director = dynamic_cast<SwigDirector_CustomAlgorithmInterface *>(obj);
92309   if (director) {
92310     director->swig_connect_director(callback0);
92311   }
92312 }
92313
92314
92315 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetCustomAlgorithm(void * jarg1, void * jarg2) {
92316   KeyboardFocusManager arg1 ;
92317   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg2 = 0 ;
92318   KeyboardFocusManager *argp1 ;
92319
92320   argp1 = (KeyboardFocusManager *)jarg1;
92321   if (!argp1) {
92322     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null KeyboardFocusManager", 0);
92323     return ;
92324   }
92325   arg1 = *argp1;
92326   arg2 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg2;
92327   if (!arg2) {
92328     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface & type is null", 0);
92329     return ;
92330   }
92331   {
92332     try {
92333       Dali::Toolkit::DevelKeyboardFocusManager::SetCustomAlgorithm(arg1,*arg2);
92334     } catch (std::out_of_range& e) {
92335       {
92336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92337       };
92338     } catch (std::exception& e) {
92339       {
92340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92341       };
92342     } catch (Dali::DaliException e) {
92343       {
92344         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92345       };
92346     } catch (...) {
92347       {
92348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92349       };
92350     }
92351   }
92352
92353 }
92354
92355
92356 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Clear(void * jarg1) {
92357   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92358
92359   arg1 = (std::vector< unsigned int > *)jarg1;
92360   {
92361     try {
92362       (arg1)->clear();
92363     } catch (std::out_of_range& e) {
92364       {
92365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92366       };
92367     } catch (std::exception& e) {
92368       {
92369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92370       };
92371     } catch (Dali::DaliException e) {
92372       {
92373         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92374       };
92375     } catch (...) {
92376       {
92377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92378       };
92379     }
92380   }
92381
92382 }
92383
92384
92385 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Add(void * jarg1, unsigned int jarg2) {
92386   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92387   unsigned int *arg2 = 0 ;
92388   unsigned int temp2 ;
92389
92390   arg1 = (std::vector< unsigned int > *)jarg1;
92391   temp2 = (unsigned int)jarg2;
92392   arg2 = &temp2;
92393   {
92394     try {
92395       (arg1)->push_back((unsigned int const &)*arg2);
92396     } catch (std::out_of_range& e) {
92397       {
92398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92399       };
92400     } catch (std::exception& e) {
92401       {
92402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92403       };
92404     } catch (Dali::DaliException e) {
92405       {
92406         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92407       };
92408     } catch (...) {
92409       {
92410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92411       };
92412     }
92413   }
92414
92415 }
92416
92417
92418 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_size(void * jarg1) {
92419   unsigned long jresult ;
92420   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92421   std::vector< unsigned int >::size_type result;
92422
92423   arg1 = (std::vector< unsigned int > *)jarg1;
92424   {
92425     try {
92426       result = ((std::vector< unsigned int > const *)arg1)->size();
92427     } catch (std::out_of_range& e) {
92428       {
92429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92430       };
92431     } catch (std::exception& e) {
92432       {
92433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92434       };
92435     } catch (Dali::DaliException e) {
92436       {
92437         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92438       };
92439     } catch (...) {
92440       {
92441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92442       };
92443     }
92444   }
92445
92446   jresult = (unsigned long)result;
92447   return jresult;
92448 }
92449
92450
92451 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_capacity(void * jarg1) {
92452   unsigned long jresult ;
92453   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92454   std::vector< unsigned int >::size_type result;
92455
92456   arg1 = (std::vector< unsigned int > *)jarg1;
92457   {
92458     try {
92459       result = ((std::vector< unsigned int > const *)arg1)->capacity();
92460     } catch (std::out_of_range& e) {
92461       {
92462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92463       };
92464     } catch (std::exception& e) {
92465       {
92466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92467       };
92468     } catch (Dali::DaliException e) {
92469       {
92470         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92471       };
92472     } catch (...) {
92473       {
92474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92475       };
92476     }
92477   }
92478
92479   jresult = (unsigned long)result;
92480   return jresult;
92481 }
92482
92483
92484 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_reserve(void * jarg1, unsigned long jarg2) {
92485   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92486   std::vector< unsigned int >::size_type arg2 ;
92487
92488   arg1 = (std::vector< unsigned int > *)jarg1;
92489   arg2 = (std::vector< unsigned int >::size_type)jarg2;
92490   {
92491     try {
92492       (arg1)->reserve(arg2);
92493     } catch (std::out_of_range& e) {
92494       {
92495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92496       };
92497     } catch (std::exception& e) {
92498       {
92499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92500       };
92501     } catch (Dali::DaliException e) {
92502       {
92503         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92504       };
92505     } catch (...) {
92506       {
92507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92508       };
92509     }
92510   }
92511
92512 }
92513
92514
92515 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_0() {
92516   void * jresult ;
92517   std::vector< unsigned int > *result = 0 ;
92518
92519   {
92520     try {
92521       result = (std::vector< unsigned int > *)new std::vector< unsigned int >();
92522     } catch (std::out_of_range& e) {
92523       {
92524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92525       };
92526     } catch (std::exception& e) {
92527       {
92528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92529       };
92530     } catch (Dali::DaliException e) {
92531       {
92532         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92533       };
92534     } catch (...) {
92535       {
92536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92537       };
92538     }
92539   }
92540
92541   jresult = (void *)result;
92542   return jresult;
92543 }
92544
92545
92546 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_1(void * jarg1) {
92547   void * jresult ;
92548   std::vector< unsigned int > *arg1 = 0 ;
92549   std::vector< unsigned int > *result = 0 ;
92550
92551   arg1 = (std::vector< unsigned int > *)jarg1;
92552   if (!arg1) {
92553     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
92554     return 0;
92555   }
92556   {
92557     try {
92558       result = (std::vector< unsigned int > *)new std::vector< unsigned int >((std::vector< unsigned int > const &)*arg1);
92559     } catch (std::out_of_range& e) {
92560       {
92561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92562       };
92563     } catch (std::exception& e) {
92564       {
92565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92566       };
92567     } catch (Dali::DaliException e) {
92568       {
92569         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92570       };
92571     } catch (...) {
92572       {
92573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92574       };
92575     }
92576   }
92577
92578   jresult = (void *)result;
92579   return jresult;
92580 }
92581
92582
92583 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_2(int jarg1) {
92584   void * jresult ;
92585   int arg1 ;
92586   std::vector< unsigned int > *result = 0 ;
92587
92588   arg1 = (int)jarg1;
92589   {
92590     try {
92591       try {
92592         result = (std::vector< unsigned int > *)new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(arg1);
92593       }
92594       catch(std::out_of_range &_e) {
92595         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92596         return 0;
92597       }
92598
92599     } catch (std::out_of_range& e) {
92600       {
92601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92602       };
92603     } catch (std::exception& e) {
92604       {
92605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92606       };
92607     } catch (Dali::DaliException e) {
92608       {
92609         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92610       };
92611     } catch (...) {
92612       {
92613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92614       };
92615     }
92616   }
92617
92618   jresult = (void *)result;
92619   return jresult;
92620 }
92621
92622
92623 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitemcopy(void * jarg1, int jarg2) {
92624   unsigned int jresult ;
92625   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92626   int arg2 ;
92627   unsigned int result;
92628
92629   arg1 = (std::vector< unsigned int > *)jarg1;
92630   arg2 = (int)jarg2;
92631   {
92632     try {
92633       try {
92634         result = (unsigned int)std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(arg1,arg2);
92635       }
92636       catch(std::out_of_range &_e) {
92637         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92638         return 0;
92639       }
92640
92641     } catch (std::out_of_range& e) {
92642       {
92643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92644       };
92645     } catch (std::exception& e) {
92646       {
92647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92648       };
92649     } catch (Dali::DaliException e) {
92650       {
92651         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92652       };
92653     } catch (...) {
92654       {
92655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92656       };
92657     }
92658   }
92659
92660   jresult = result;
92661   return jresult;
92662 }
92663
92664
92665 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitem(void * jarg1, int jarg2) {
92666   unsigned int jresult ;
92667   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92668   int arg2 ;
92669   unsigned int *result = 0 ;
92670
92671   arg1 = (std::vector< unsigned int > *)jarg1;
92672   arg2 = (int)jarg2;
92673   {
92674     try {
92675       try {
92676         result = (unsigned int *) &std_vector_Sl_unsigned_SS_int_Sg__getitem(arg1,arg2);
92677       }
92678       catch(std::out_of_range &_e) {
92679         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92680         return 0;
92681       }
92682
92683     } catch (std::out_of_range& e) {
92684       {
92685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92686       };
92687     } catch (std::exception& e) {
92688       {
92689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92690       };
92691     } catch (Dali::DaliException e) {
92692       {
92693         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92694       };
92695     } catch (...) {
92696       {
92697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92698       };
92699     }
92700   }
92701
92702   jresult = *result;
92703   return jresult;
92704 }
92705
92706
92707 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_setitem(void * jarg1, int jarg2, unsigned int jarg3) {
92708   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92709   int arg2 ;
92710   unsigned int *arg3 = 0 ;
92711   unsigned int temp3 ;
92712
92713   arg1 = (std::vector< unsigned int > *)jarg1;
92714   arg2 = (int)jarg2;
92715   temp3 = (unsigned int)jarg3;
92716   arg3 = &temp3;
92717   {
92718     try {
92719       try {
92720         std_vector_Sl_unsigned_SS_int_Sg__setitem(arg1,arg2,(unsigned int const &)*arg3);
92721       }
92722       catch(std::out_of_range &_e) {
92723         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92724         return ;
92725       }
92726
92727     } catch (std::out_of_range& e) {
92728       {
92729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92730       };
92731     } catch (std::exception& e) {
92732       {
92733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92734       };
92735     } catch (Dali::DaliException e) {
92736       {
92737         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92738       };
92739     } catch (...) {
92740       {
92741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92742       };
92743     }
92744   }
92745
92746 }
92747
92748
92749 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_AddRange(void * jarg1, void * jarg2) {
92750   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92751   std::vector< unsigned int > *arg2 = 0 ;
92752
92753   arg1 = (std::vector< unsigned int > *)jarg1;
92754   arg2 = (std::vector< unsigned int > *)jarg2;
92755   if (!arg2) {
92756     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
92757     return ;
92758   }
92759   {
92760     try {
92761       std_vector_Sl_unsigned_SS_int_Sg__AddRange(arg1,(std::vector< unsigned int > const &)*arg2);
92762     } catch (std::out_of_range& e) {
92763       {
92764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92765       };
92766     } catch (std::exception& e) {
92767       {
92768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92769       };
92770     } catch (Dali::DaliException e) {
92771       {
92772         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92773       };
92774     } catch (...) {
92775       {
92776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92777       };
92778     }
92779   }
92780
92781 }
92782
92783
92784 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
92785   void * jresult ;
92786   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92787   int arg2 ;
92788   int arg3 ;
92789   std::vector< unsigned int > *result = 0 ;
92790
92791   arg1 = (std::vector< unsigned int > *)jarg1;
92792   arg2 = (int)jarg2;
92793   arg3 = (int)jarg3;
92794   {
92795     try {
92796       try {
92797         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__GetRange(arg1,arg2,arg3);
92798       }
92799       catch(std::out_of_range &_e) {
92800         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92801         return 0;
92802       }
92803       catch(std::invalid_argument &_e) {
92804         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
92805         return 0;
92806       }
92807
92808     } catch (std::out_of_range& e) {
92809       {
92810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92811       };
92812     } catch (std::exception& e) {
92813       {
92814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92815       };
92816     } catch (Dali::DaliException e) {
92817       {
92818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92819       };
92820     } catch (...) {
92821       {
92822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92823       };
92824     }
92825   }
92826
92827   jresult = (void *)result;
92828   return jresult;
92829 }
92830
92831
92832 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Insert(void * jarg1, int jarg2, unsigned int jarg3) {
92833   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92834   int arg2 ;
92835   unsigned int *arg3 = 0 ;
92836   unsigned int temp3 ;
92837
92838   arg1 = (std::vector< unsigned int > *)jarg1;
92839   arg2 = (int)jarg2;
92840   temp3 = (unsigned int)jarg3;
92841   arg3 = &temp3;
92842   {
92843     try {
92844       try {
92845         std_vector_Sl_unsigned_SS_int_Sg__Insert(arg1,arg2,(unsigned int const &)*arg3);
92846       }
92847       catch(std::out_of_range &_e) {
92848         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92849         return ;
92850       }
92851
92852     } catch (std::out_of_range& e) {
92853       {
92854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92855       };
92856     } catch (std::exception& e) {
92857       {
92858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92859       };
92860     } catch (Dali::DaliException e) {
92861       {
92862         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92863       };
92864     } catch (...) {
92865       {
92866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92867       };
92868     }
92869   }
92870
92871 }
92872
92873
92874 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
92875   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92876   int arg2 ;
92877   std::vector< unsigned int > *arg3 = 0 ;
92878
92879   arg1 = (std::vector< unsigned int > *)jarg1;
92880   arg2 = (int)jarg2;
92881   arg3 = (std::vector< unsigned int > *)jarg3;
92882   if (!arg3) {
92883     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
92884     return ;
92885   }
92886   {
92887     try {
92888       try {
92889         std_vector_Sl_unsigned_SS_int_Sg__InsertRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
92890       }
92891       catch(std::out_of_range &_e) {
92892         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92893         return ;
92894       }
92895
92896     } catch (std::out_of_range& e) {
92897       {
92898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92899       };
92900     } catch (std::exception& e) {
92901       {
92902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92903       };
92904     } catch (Dali::DaliException e) {
92905       {
92906         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92907       };
92908     } catch (...) {
92909       {
92910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92911       };
92912     }
92913   }
92914
92915 }
92916
92917
92918 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveAt(void * jarg1, int jarg2) {
92919   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92920   int arg2 ;
92921
92922   arg1 = (std::vector< unsigned int > *)jarg1;
92923   arg2 = (int)jarg2;
92924   {
92925     try {
92926       try {
92927         std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(arg1,arg2);
92928       }
92929       catch(std::out_of_range &_e) {
92930         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92931         return ;
92932       }
92933
92934     } catch (std::out_of_range& e) {
92935       {
92936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92937       };
92938     } catch (std::exception& e) {
92939       {
92940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92941       };
92942     } catch (Dali::DaliException e) {
92943       {
92944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92945       };
92946     } catch (...) {
92947       {
92948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92949       };
92950     }
92951   }
92952
92953 }
92954
92955
92956 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
92957   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92958   int arg2 ;
92959   int arg3 ;
92960
92961   arg1 = (std::vector< unsigned int > *)jarg1;
92962   arg2 = (int)jarg2;
92963   arg3 = (int)jarg3;
92964   {
92965     try {
92966       try {
92967         std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(arg1,arg2,arg3);
92968       }
92969       catch(std::out_of_range &_e) {
92970         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92971         return ;
92972       }
92973       catch(std::invalid_argument &_e) {
92974         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
92975         return ;
92976       }
92977
92978     } catch (std::out_of_range& e) {
92979       {
92980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92981       };
92982     } catch (std::exception& e) {
92983       {
92984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92985       };
92986     } catch (Dali::DaliException e) {
92987       {
92988         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92989       };
92990     } catch (...) {
92991       {
92992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92993       };
92994     }
92995   }
92996
92997 }
92998
92999
93000 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_Repeat(unsigned int jarg1, int jarg2) {
93001   void * jresult ;
93002   unsigned int *arg1 = 0 ;
93003   int arg2 ;
93004   unsigned int temp1 ;
93005   std::vector< unsigned int > *result = 0 ;
93006
93007   temp1 = (unsigned int)jarg1;
93008   arg1 = &temp1;
93009   arg2 = (int)jarg2;
93010   {
93011     try {
93012       try {
93013         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__Repeat((unsigned int const &)*arg1,arg2);
93014       }
93015       catch(std::out_of_range &_e) {
93016         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93017         return 0;
93018       }
93019
93020     } catch (std::out_of_range& e) {
93021       {
93022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93023       };
93024     } catch (std::exception& e) {
93025       {
93026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93027       };
93028     } catch (Dali::DaliException e) {
93029       {
93030         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93031       };
93032     } catch (...) {
93033       {
93034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93035       };
93036     }
93037   }
93038
93039   jresult = (void *)result;
93040   return jresult;
93041 }
93042
93043
93044 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_0(void * jarg1) {
93045   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93046
93047   arg1 = (std::vector< unsigned int > *)jarg1;
93048   {
93049     try {
93050       std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(arg1);
93051     } catch (std::out_of_range& e) {
93052       {
93053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93054       };
93055     } catch (std::exception& e) {
93056       {
93057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93058       };
93059     } catch (Dali::DaliException e) {
93060       {
93061         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93062       };
93063     } catch (...) {
93064       {
93065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93066       };
93067     }
93068   }
93069
93070 }
93071
93072
93073 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
93074   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93075   int arg2 ;
93076   int arg3 ;
93077
93078   arg1 = (std::vector< unsigned int > *)jarg1;
93079   arg2 = (int)jarg2;
93080   arg3 = (int)jarg3;
93081   {
93082     try {
93083       try {
93084         std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
93085       }
93086       catch(std::out_of_range &_e) {
93087         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93088         return ;
93089       }
93090       catch(std::invalid_argument &_e) {
93091         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
93092         return ;
93093       }
93094
93095     } catch (std::out_of_range& e) {
93096       {
93097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93098       };
93099     } catch (std::exception& e) {
93100       {
93101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93102       };
93103     } catch (Dali::DaliException e) {
93104       {
93105         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93106       };
93107     } catch (...) {
93108       {
93109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93110       };
93111     }
93112   }
93113
93114 }
93115
93116
93117 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
93118   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93119   int arg2 ;
93120   std::vector< unsigned int > *arg3 = 0 ;
93121
93122   arg1 = (std::vector< unsigned int > *)jarg1;
93123   arg2 = (int)jarg2;
93124   arg3 = (std::vector< unsigned int > *)jarg3;
93125   if (!arg3) {
93126     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
93127     return ;
93128   }
93129   {
93130     try {
93131       try {
93132         std_vector_Sl_unsigned_SS_int_Sg__SetRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
93133       }
93134       catch(std::out_of_range &_e) {
93135         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93136         return ;
93137       }
93138
93139     } catch (std::out_of_range& e) {
93140       {
93141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93142       };
93143     } catch (std::exception& e) {
93144       {
93145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93146       };
93147     } catch (Dali::DaliException e) {
93148       {
93149         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93150       };
93151     } catch (...) {
93152       {
93153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93154       };
93155     }
93156   }
93157
93158 }
93159
93160
93161 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Contains(void * jarg1, unsigned int jarg2) {
93162   unsigned int jresult ;
93163   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93164   unsigned int *arg2 = 0 ;
93165   unsigned int temp2 ;
93166   bool result;
93167
93168   arg1 = (std::vector< unsigned int > *)jarg1;
93169   temp2 = (unsigned int)jarg2;
93170   arg2 = &temp2;
93171   {
93172     try {
93173       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Contains(arg1,(unsigned int const &)*arg2);
93174     } catch (std::out_of_range& e) {
93175       {
93176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93177       };
93178     } catch (std::exception& e) {
93179       {
93180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93181       };
93182     } catch (Dali::DaliException e) {
93183       {
93184         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93185       };
93186     } catch (...) {
93187       {
93188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93189       };
93190     }
93191   }
93192
93193   jresult = result;
93194   return jresult;
93195 }
93196
93197
93198 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_IndexOf(void * jarg1, unsigned int jarg2) {
93199   int jresult ;
93200   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93201   unsigned int *arg2 = 0 ;
93202   unsigned int temp2 ;
93203   int result;
93204
93205   arg1 = (std::vector< unsigned int > *)jarg1;
93206   temp2 = (unsigned int)jarg2;
93207   arg2 = &temp2;
93208   {
93209     try {
93210       result = (int)std_vector_Sl_unsigned_SS_int_Sg__IndexOf(arg1,(unsigned int const &)*arg2);
93211     } catch (std::out_of_range& e) {
93212       {
93213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93214       };
93215     } catch (std::exception& e) {
93216       {
93217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93218       };
93219     } catch (Dali::DaliException e) {
93220       {
93221         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93222       };
93223     } catch (...) {
93224       {
93225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93226       };
93227     }
93228   }
93229
93230   jresult = result;
93231   return jresult;
93232 }
93233
93234
93235 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_LastIndexOf(void * jarg1, unsigned int jarg2) {
93236   int jresult ;
93237   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93238   unsigned int *arg2 = 0 ;
93239   unsigned int temp2 ;
93240   int result;
93241
93242   arg1 = (std::vector< unsigned int > *)jarg1;
93243   temp2 = (unsigned int)jarg2;
93244   arg2 = &temp2;
93245   {
93246     try {
93247       result = (int)std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(arg1,(unsigned int const &)*arg2);
93248     } catch (std::out_of_range& e) {
93249       {
93250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93251       };
93252     } catch (std::exception& e) {
93253       {
93254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93255       };
93256     } catch (Dali::DaliException e) {
93257       {
93258         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93259       };
93260     } catch (...) {
93261       {
93262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93263       };
93264     }
93265   }
93266
93267   jresult = result;
93268   return jresult;
93269 }
93270
93271
93272 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Remove(void * jarg1, unsigned int jarg2) {
93273   unsigned int jresult ;
93274   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93275   unsigned int *arg2 = 0 ;
93276   unsigned int temp2 ;
93277   bool result;
93278
93279   arg1 = (std::vector< unsigned int > *)jarg1;
93280   temp2 = (unsigned int)jarg2;
93281   arg2 = &temp2;
93282   {
93283     try {
93284       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Remove(arg1,(unsigned int const &)*arg2);
93285     } catch (std::out_of_range& e) {
93286       {
93287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93288       };
93289     } catch (std::exception& e) {
93290       {
93291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93292       };
93293     } catch (Dali::DaliException e) {
93294       {
93295         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93296       };
93297     } catch (...) {
93298       {
93299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93300       };
93301     }
93302   }
93303
93304   jresult = result;
93305   return jresult;
93306 }
93307
93308
93309 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemIdContainer(void * jarg1) {
93310   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93311
93312   arg1 = (std::vector< unsigned int > *)jarg1;
93313   {
93314     try {
93315       delete arg1;
93316     } catch (std::out_of_range& e) {
93317       {
93318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93319       };
93320     } catch (std::exception& e) {
93321       {
93322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93323       };
93324     } catch (Dali::DaliException e) {
93325       {
93326         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93327       };
93328     } catch (...) {
93329       {
93330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93331       };
93332     }
93333   }
93334
93335 }
93336
93337
93338 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_0() {
93339   void * jresult ;
93340   std::pair< unsigned int,Dali::Actor > *result = 0 ;
93341
93342   {
93343     try {
93344       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >();
93345     } catch (std::out_of_range& e) {
93346       {
93347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93348       };
93349     } catch (std::exception& e) {
93350       {
93351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93352       };
93353     } catch (Dali::DaliException e) {
93354       {
93355         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93356       };
93357     } catch (...) {
93358       {
93359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93360       };
93361     }
93362   }
93363
93364   jresult = (void *)result;
93365   return jresult;
93366 }
93367
93368
93369 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_1(unsigned int jarg1, void * jarg2) {
93370   void * jresult ;
93371   unsigned int arg1 ;
93372   Dali::Actor arg2 ;
93373   Dali::Actor *argp2 ;
93374   std::pair< unsigned int,Dali::Actor > *result = 0 ;
93375
93376   arg1 = (unsigned int)jarg1;
93377   argp2 = (Dali::Actor *)jarg2;
93378   if (!argp2) {
93379     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
93380     return 0;
93381   }
93382   arg2 = *argp2;
93383   {
93384     try {
93385       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >(arg1,arg2);
93386     } catch (std::out_of_range& e) {
93387       {
93388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93389       };
93390     } catch (std::exception& e) {
93391       {
93392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93393       };
93394     } catch (Dali::DaliException e) {
93395       {
93396         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93397       };
93398     } catch (...) {
93399       {
93400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93401       };
93402     }
93403   }
93404
93405   jresult = (void *)result;
93406   return jresult;
93407 }
93408
93409
93410 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_2(void * jarg1) {
93411   void * jresult ;
93412   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
93413   std::pair< unsigned int,Dali::Actor > *result = 0 ;
93414
93415   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93416   if (!arg1) {
93417     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
93418     return 0;
93419   }
93420   {
93421     try {
93422       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >((std::pair< unsigned int,Dali::Actor > const &)*arg1);
93423     } catch (std::out_of_range& e) {
93424       {
93425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93426       };
93427     } catch (std::exception& e) {
93428       {
93429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93430       };
93431     } catch (Dali::DaliException e) {
93432       {
93433         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93434       };
93435     } catch (...) {
93436       {
93437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93438       };
93439     }
93440   }
93441
93442   jresult = (void *)result;
93443   return jresult;
93444 }
93445
93446
93447 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_first_set(void * jarg1, unsigned int jarg2) {
93448   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
93449   unsigned int arg2 ;
93450
93451   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93452   arg2 = (unsigned int)jarg2;
93453   if (arg1) (arg1)->first = arg2;
93454 }
93455
93456
93457 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Item_first_get(void * jarg1) {
93458   unsigned int jresult ;
93459   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
93460   unsigned int result;
93461
93462   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93463   result = (unsigned int) ((arg1)->first);
93464   jresult = result;
93465   return jresult;
93466 }
93467
93468
93469 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_second_set(void * jarg1, void * jarg2) {
93470   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
93471   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
93472
93473   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93474   arg2 = (Dali::Actor *)jarg2;
93475   if (arg1) (arg1)->second = *arg2;
93476 }
93477
93478
93479 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Item_second_get(void * jarg1) {
93480   void * jresult ;
93481   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
93482   Dali::Actor *result = 0 ;
93483
93484   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93485   result = (Dali::Actor *)& ((arg1)->second);
93486   jresult = (void *)result;
93487   return jresult;
93488 }
93489
93490
93491 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Item(void * jarg1) {
93492   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
93493
93494   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93495   {
93496     try {
93497       delete arg1;
93498     } catch (std::out_of_range& e) {
93499       {
93500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93501       };
93502     } catch (std::exception& e) {
93503       {
93504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93505       };
93506     } catch (Dali::DaliException e) {
93507       {
93508         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93509       };
93510     } catch (...) {
93511       {
93512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93513       };
93514     }
93515   }
93516
93517 }
93518
93519
93520 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Clear(void * jarg1) {
93521   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93522
93523   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93524   {
93525     try {
93526       (arg1)->clear();
93527     } catch (std::out_of_range& e) {
93528       {
93529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93530       };
93531     } catch (std::exception& e) {
93532       {
93533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93534       };
93535     } catch (Dali::DaliException e) {
93536       {
93537         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93538       };
93539     } catch (...) {
93540       {
93541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93542       };
93543     }
93544   }
93545
93546 }
93547
93548
93549 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Add(void * jarg1, void * jarg2) {
93550   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93551   std::pair< unsigned int,Dali::Actor > *arg2 = 0 ;
93552
93553   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93554   arg2 = (std::pair< unsigned int,Dali::Actor > *)jarg2;
93555   if (!arg2) {
93556     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
93557     return ;
93558   }
93559   {
93560     try {
93561       (arg1)->push_back((std::pair< unsigned int,Dali::Actor > const &)*arg2);
93562     } catch (std::out_of_range& e) {
93563       {
93564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93565       };
93566     } catch (std::exception& e) {
93567       {
93568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93569       };
93570     } catch (Dali::DaliException e) {
93571       {
93572         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93573       };
93574     } catch (...) {
93575       {
93576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93577       };
93578     }
93579   }
93580
93581 }
93582
93583
93584 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_size(void * jarg1) {
93585   unsigned long jresult ;
93586   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93587   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
93588
93589   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93590   {
93591     try {
93592       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->size();
93593     } catch (std::out_of_range& e) {
93594       {
93595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93596       };
93597     } catch (std::exception& e) {
93598       {
93599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93600       };
93601     } catch (Dali::DaliException e) {
93602       {
93603         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93604       };
93605     } catch (...) {
93606       {
93607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93608       };
93609     }
93610   }
93611
93612   jresult = (unsigned long)result;
93613   return jresult;
93614 }
93615
93616
93617 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_capacity(void * jarg1) {
93618   unsigned long jresult ;
93619   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93620   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
93621
93622   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93623   {
93624     try {
93625       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->capacity();
93626     } catch (std::out_of_range& e) {
93627       {
93628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93629       };
93630     } catch (std::exception& e) {
93631       {
93632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93633       };
93634     } catch (Dali::DaliException e) {
93635       {
93636         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93637       };
93638     } catch (...) {
93639       {
93640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93641       };
93642     }
93643   }
93644
93645   jresult = (unsigned long)result;
93646   return jresult;
93647 }
93648
93649
93650 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_reserve(void * jarg1, unsigned long jarg2) {
93651   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93652   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type arg2 ;
93653
93654   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93655   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > >::size_type)jarg2;
93656   {
93657     try {
93658       (arg1)->reserve(arg2);
93659     } catch (std::out_of_range& e) {
93660       {
93661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93662       };
93663     } catch (std::exception& e) {
93664       {
93665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93666       };
93667     } catch (Dali::DaliException e) {
93668       {
93669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93670       };
93671     } catch (...) {
93672       {
93673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93674       };
93675     }
93676   }
93677
93678 }
93679
93680
93681 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_0() {
93682   void * jresult ;
93683   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
93684
93685   {
93686     try {
93687       result = (std::vector< std::pair< unsigned int,Dali::Actor > > *)new std::vector< std::pair< unsigned int,Dali::Actor > >();
93688     } catch (std::out_of_range& e) {
93689       {
93690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93691       };
93692     } catch (std::exception& e) {
93693       {
93694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93695       };
93696     } catch (Dali::DaliException e) {
93697       {
93698         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93699       };
93700     } catch (...) {
93701       {
93702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93703       };
93704     }
93705   }
93706
93707   jresult = (void *)result;
93708   return jresult;
93709 }
93710
93711
93712 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_1(void * jarg1) {
93713   void * jresult ;
93714   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = 0 ;
93715   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
93716
93717   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93718   if (!arg1) {
93719     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
93720     return 0;
93721   }
93722   {
93723     try {
93724       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);
93725     } catch (std::out_of_range& e) {
93726       {
93727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93728       };
93729     } catch (std::exception& e) {
93730       {
93731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93732       };
93733     } catch (Dali::DaliException e) {
93734       {
93735         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93736       };
93737     } catch (...) {
93738       {
93739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93740       };
93741     }
93742   }
93743
93744   jresult = (void *)result;
93745   return jresult;
93746 }
93747
93748
93749 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_2(int jarg1) {
93750   void * jresult ;
93751   int arg1 ;
93752   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
93753
93754   arg1 = (int)jarg1;
93755   {
93756     try {
93757       try {
93758         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);
93759       }
93760       catch(std::out_of_range &_e) {
93761         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93762         return 0;
93763       }
93764
93765     } catch (std::out_of_range& e) {
93766       {
93767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93768       };
93769     } catch (std::exception& e) {
93770       {
93771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93772       };
93773     } catch (Dali::DaliException e) {
93774       {
93775         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93776       };
93777     } catch (...) {
93778       {
93779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93780       };
93781     }
93782   }
93783
93784   jresult = (void *)result;
93785   return jresult;
93786 }
93787
93788
93789 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitemcopy(void * jarg1, int jarg2) {
93790   void * jresult ;
93791   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93792   int arg2 ;
93793   std::pair< unsigned int,Dali::Actor > result;
93794
93795   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93796   arg2 = (int)jarg2;
93797   {
93798     try {
93799       try {
93800         result = std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitemcopy(arg1,arg2);
93801       }
93802       catch(std::out_of_range &_e) {
93803         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93804         return 0;
93805       }
93806
93807     } catch (std::out_of_range& e) {
93808       {
93809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93810       };
93811     } catch (std::exception& e) {
93812       {
93813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93814       };
93815     } catch (Dali::DaliException e) {
93816       {
93817         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93818       };
93819     } catch (...) {
93820       {
93821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93822       };
93823     }
93824   }
93825
93826   jresult = new std::pair< unsigned int,Dali::Actor >((const std::pair< unsigned int,Dali::Actor > &)result);
93827   return jresult;
93828 }
93829
93830
93831 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitem(void * jarg1, int jarg2) {
93832   void * jresult ;
93833   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93834   int arg2 ;
93835   std::pair< unsigned int,Dali::Actor > *result = 0 ;
93836
93837   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93838   arg2 = (int)jarg2;
93839   {
93840     try {
93841       try {
93842         result = (std::pair< unsigned int,Dali::Actor > *) &std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitem(arg1,arg2);
93843       }
93844       catch(std::out_of_range &_e) {
93845         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93846         return 0;
93847       }
93848
93849     } catch (std::out_of_range& e) {
93850       {
93851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93852       };
93853     } catch (std::exception& e) {
93854       {
93855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93856       };
93857     } catch (Dali::DaliException e) {
93858       {
93859         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93860       };
93861     } catch (...) {
93862       {
93863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93864       };
93865     }
93866   }
93867
93868   jresult = (void *)result;
93869   return jresult;
93870 }
93871
93872
93873 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
93874   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93875   int arg2 ;
93876   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
93877
93878   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93879   arg2 = (int)jarg2;
93880   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
93881   if (!arg3) {
93882     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
93883     return ;
93884   }
93885   {
93886     try {
93887       try {
93888         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);
93889       }
93890       catch(std::out_of_range &_e) {
93891         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93892         return ;
93893       }
93894
93895     } catch (std::out_of_range& e) {
93896       {
93897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93898       };
93899     } catch (std::exception& e) {
93900       {
93901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93902       };
93903     } catch (Dali::DaliException e) {
93904       {
93905         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93906       };
93907     } catch (...) {
93908       {
93909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93910       };
93911     }
93912   }
93913
93914 }
93915
93916
93917 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_AddRange(void * jarg1, void * jarg2) {
93918   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93919   std::vector< std::pair< unsigned int,Dali::Actor > > *arg2 = 0 ;
93920
93921   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93922   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg2;
93923   if (!arg2) {
93924     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
93925     return ;
93926   }
93927   {
93928     try {
93929       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);
93930     } catch (std::out_of_range& e) {
93931       {
93932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93933       };
93934     } catch (std::exception& e) {
93935       {
93936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93937       };
93938     } catch (Dali::DaliException e) {
93939       {
93940         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93941       };
93942     } catch (...) {
93943       {
93944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93945       };
93946     }
93947   }
93948
93949 }
93950
93951
93952 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
93953   void * jresult ;
93954   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93955   int arg2 ;
93956   int arg3 ;
93957   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
93958
93959   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93960   arg2 = (int)jarg2;
93961   arg3 = (int)jarg3;
93962   {
93963     try {
93964       try {
93965         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);
93966       }
93967       catch(std::out_of_range &_e) {
93968         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93969         return 0;
93970       }
93971       catch(std::invalid_argument &_e) {
93972         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
93973         return 0;
93974       }
93975
93976     } catch (std::out_of_range& e) {
93977       {
93978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93979       };
93980     } catch (std::exception& e) {
93981       {
93982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93983       };
93984     } catch (Dali::DaliException e) {
93985       {
93986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93987       };
93988     } catch (...) {
93989       {
93990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93991       };
93992     }
93993   }
93994
93995   jresult = (void *)result;
93996   return jresult;
93997 }
93998
93999
94000 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
94001   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94002   int arg2 ;
94003   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
94004
94005   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94006   arg2 = (int)jarg2;
94007   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
94008   if (!arg3) {
94009     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
94010     return ;
94011   }
94012   {
94013     try {
94014       try {
94015         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);
94016       }
94017       catch(std::out_of_range &_e) {
94018         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94019         return ;
94020       }
94021
94022     } catch (std::out_of_range& e) {
94023       {
94024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94025       };
94026     } catch (std::exception& e) {
94027       {
94028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94029       };
94030     } catch (Dali::DaliException e) {
94031       {
94032         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94033       };
94034     } catch (...) {
94035       {
94036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94037       };
94038     }
94039   }
94040
94041 }
94042
94043
94044 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
94045   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94046   int arg2 ;
94047   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
94048
94049   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94050   arg2 = (int)jarg2;
94051   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
94052   if (!arg3) {
94053     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
94054     return ;
94055   }
94056   {
94057     try {
94058       try {
94059         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);
94060       }
94061       catch(std::out_of_range &_e) {
94062         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94063         return ;
94064       }
94065
94066     } catch (std::out_of_range& e) {
94067       {
94068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94069       };
94070     } catch (std::exception& e) {
94071       {
94072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94073       };
94074     } catch (Dali::DaliException e) {
94075       {
94076         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94077       };
94078     } catch (...) {
94079       {
94080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94081       };
94082     }
94083   }
94084
94085 }
94086
94087
94088 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveAt(void * jarg1, int jarg2) {
94089   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94090   int arg2 ;
94091
94092   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94093   arg2 = (int)jarg2;
94094   {
94095     try {
94096       try {
94097         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveAt(arg1,arg2);
94098       }
94099       catch(std::out_of_range &_e) {
94100         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94101         return ;
94102       }
94103
94104     } catch (std::out_of_range& e) {
94105       {
94106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94107       };
94108     } catch (std::exception& e) {
94109       {
94110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94111       };
94112     } catch (Dali::DaliException e) {
94113       {
94114         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94115       };
94116     } catch (...) {
94117       {
94118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94119       };
94120     }
94121   }
94122
94123 }
94124
94125
94126 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
94127   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94128   int arg2 ;
94129   int arg3 ;
94130
94131   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94132   arg2 = (int)jarg2;
94133   arg3 = (int)jarg3;
94134   {
94135     try {
94136       try {
94137         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveRange(arg1,arg2,arg3);
94138       }
94139       catch(std::out_of_range &_e) {
94140         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94141         return ;
94142       }
94143       catch(std::invalid_argument &_e) {
94144         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
94145         return ;
94146       }
94147
94148     } catch (std::out_of_range& e) {
94149       {
94150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94151       };
94152     } catch (std::exception& e) {
94153       {
94154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94155       };
94156     } catch (Dali::DaliException e) {
94157       {
94158         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94159       };
94160     } catch (...) {
94161       {
94162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94163       };
94164     }
94165   }
94166
94167 }
94168
94169
94170 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_Repeat(void * jarg1, int jarg2) {
94171   void * jresult ;
94172   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
94173   int arg2 ;
94174   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
94175
94176   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
94177   if (!arg1) {
94178     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
94179     return 0;
94180   }
94181   arg2 = (int)jarg2;
94182   {
94183     try {
94184       try {
94185         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);
94186       }
94187       catch(std::out_of_range &_e) {
94188         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94189         return 0;
94190       }
94191
94192     } catch (std::out_of_range& e) {
94193       {
94194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94195       };
94196     } catch (std::exception& e) {
94197       {
94198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94199       };
94200     } catch (Dali::DaliException e) {
94201       {
94202         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94203       };
94204     } catch (...) {
94205       {
94206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94207       };
94208     }
94209   }
94210
94211   jresult = (void *)result;
94212   return jresult;
94213 }
94214
94215
94216 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_0(void * jarg1) {
94217   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94218
94219   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94220   {
94221     try {
94222       std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_0(arg1);
94223     } catch (std::out_of_range& e) {
94224       {
94225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94226       };
94227     } catch (std::exception& e) {
94228       {
94229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94230       };
94231     } catch (Dali::DaliException e) {
94232       {
94233         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94234       };
94235     } catch (...) {
94236       {
94237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94238       };
94239     }
94240   }
94241
94242 }
94243
94244
94245 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
94246   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94247   int arg2 ;
94248   int arg3 ;
94249
94250   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94251   arg2 = (int)jarg2;
94252   arg3 = (int)jarg3;
94253   {
94254     try {
94255       try {
94256         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
94257       }
94258       catch(std::out_of_range &_e) {
94259         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94260         return ;
94261       }
94262       catch(std::invalid_argument &_e) {
94263         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
94264         return ;
94265       }
94266
94267     } catch (std::out_of_range& e) {
94268       {
94269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94270       };
94271     } catch (std::exception& e) {
94272       {
94273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94274       };
94275     } catch (Dali::DaliException e) {
94276       {
94277         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94278       };
94279     } catch (...) {
94280       {
94281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94282       };
94283     }
94284   }
94285
94286 }
94287
94288
94289 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
94290   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94291   int arg2 ;
94292   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
94293
94294   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94295   arg2 = (int)jarg2;
94296   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
94297   if (!arg3) {
94298     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
94299     return ;
94300   }
94301   {
94302     try {
94303       try {
94304         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);
94305       }
94306       catch(std::out_of_range &_e) {
94307         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94308         return ;
94309       }
94310
94311     } catch (std::out_of_range& e) {
94312       {
94313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94314       };
94315     } catch (std::exception& e) {
94316       {
94317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94318       };
94319     } catch (Dali::DaliException e) {
94320       {
94321         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94322       };
94323     } catch (...) {
94324       {
94325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94326       };
94327     }
94328   }
94329
94330 }
94331
94332
94333 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemContainer(void * jarg1) {
94334   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94335
94336   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94337   {
94338     try {
94339       delete arg1;
94340     } catch (std::out_of_range& e) {
94341       {
94342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94343       };
94344     } catch (std::exception& e) {
94345       {
94346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94347       };
94348     } catch (Dali::DaliException e) {
94349       {
94350         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94351       };
94352     } catch (...) {
94353       {
94354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94355       };
94356     }
94357   }
94358
94359 }
94360
94361
94362 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Clear(void * jarg1) {
94363   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94364
94365   arg1 = (std::vector< Dali::Actor > *)jarg1;
94366   {
94367     try {
94368       (arg1)->clear();
94369     } catch (std::out_of_range& e) {
94370       {
94371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94372       };
94373     } catch (std::exception& e) {
94374       {
94375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94376       };
94377     } catch (Dali::DaliException e) {
94378       {
94379         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94380       };
94381     } catch (...) {
94382       {
94383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94384       };
94385     }
94386   }
94387
94388 }
94389
94390
94391 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Add(void * jarg1, void * jarg2) {
94392   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94393   Dali::Actor *arg2 = 0 ;
94394
94395   arg1 = (std::vector< Dali::Actor > *)jarg1;
94396   arg2 = (Dali::Actor *)jarg2;
94397   if (!arg2) {
94398     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
94399     return ;
94400   }
94401   {
94402     try {
94403       (arg1)->push_back((Dali::Actor const &)*arg2);
94404     } catch (std::out_of_range& e) {
94405       {
94406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94407       };
94408     } catch (std::exception& e) {
94409       {
94410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94411       };
94412     } catch (Dali::DaliException e) {
94413       {
94414         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94415       };
94416     } catch (...) {
94417       {
94418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94419       };
94420     }
94421   }
94422
94423 }
94424
94425
94426 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_size(void * jarg1) {
94427   unsigned long jresult ;
94428   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94429   std::vector< Dali::Actor >::size_type result;
94430
94431   arg1 = (std::vector< Dali::Actor > *)jarg1;
94432   {
94433     try {
94434       result = ((std::vector< Dali::Actor > const *)arg1)->size();
94435     } catch (std::out_of_range& e) {
94436       {
94437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94438       };
94439     } catch (std::exception& e) {
94440       {
94441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94442       };
94443     } catch (Dali::DaliException e) {
94444       {
94445         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94446       };
94447     } catch (...) {
94448       {
94449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94450       };
94451     }
94452   }
94453
94454   jresult = (unsigned long)result;
94455   return jresult;
94456 }
94457
94458
94459 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_capacity(void * jarg1) {
94460   unsigned long jresult ;
94461   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94462   std::vector< Dali::Actor >::size_type result;
94463
94464   arg1 = (std::vector< Dali::Actor > *)jarg1;
94465   {
94466     try {
94467       result = ((std::vector< Dali::Actor > const *)arg1)->capacity();
94468     } catch (std::out_of_range& e) {
94469       {
94470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94471       };
94472     } catch (std::exception& e) {
94473       {
94474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94475       };
94476     } catch (Dali::DaliException e) {
94477       {
94478         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94479       };
94480     } catch (...) {
94481       {
94482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94483       };
94484     }
94485   }
94486
94487   jresult = (unsigned long)result;
94488   return jresult;
94489 }
94490
94491
94492 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_reserve(void * jarg1, unsigned long jarg2) {
94493   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94494   std::vector< Dali::Actor >::size_type arg2 ;
94495
94496   arg1 = (std::vector< Dali::Actor > *)jarg1;
94497   arg2 = (std::vector< Dali::Actor >::size_type)jarg2;
94498   {
94499     try {
94500       (arg1)->reserve(arg2);
94501     } catch (std::out_of_range& e) {
94502       {
94503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94504       };
94505     } catch (std::exception& e) {
94506       {
94507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94508       };
94509     } catch (Dali::DaliException e) {
94510       {
94511         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94512       };
94513     } catch (...) {
94514       {
94515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94516       };
94517     }
94518   }
94519
94520 }
94521
94522
94523 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_0() {
94524   void * jresult ;
94525   std::vector< Dali::Actor > *result = 0 ;
94526
94527   {
94528     try {
94529       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >();
94530     } catch (std::out_of_range& e) {
94531       {
94532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94533       };
94534     } catch (std::exception& e) {
94535       {
94536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94537       };
94538     } catch (Dali::DaliException e) {
94539       {
94540         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94541       };
94542     } catch (...) {
94543       {
94544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94545       };
94546     }
94547   }
94548
94549   jresult = (void *)result;
94550   return jresult;
94551 }
94552
94553
94554 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_1(void * jarg1) {
94555   void * jresult ;
94556   std::vector< Dali::Actor > *arg1 = 0 ;
94557   std::vector< Dali::Actor > *result = 0 ;
94558
94559   arg1 = (std::vector< Dali::Actor > *)jarg1;
94560   if (!arg1) {
94561     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
94562     return 0;
94563   }
94564   {
94565     try {
94566       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >((std::vector< Dali::Actor > const &)*arg1);
94567     } catch (std::out_of_range& e) {
94568       {
94569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94570       };
94571     } catch (std::exception& e) {
94572       {
94573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94574       };
94575     } catch (Dali::DaliException e) {
94576       {
94577         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94578       };
94579     } catch (...) {
94580       {
94581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94582       };
94583     }
94584   }
94585
94586   jresult = (void *)result;
94587   return jresult;
94588 }
94589
94590
94591 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_2(int jarg1) {
94592   void * jresult ;
94593   int arg1 ;
94594   std::vector< Dali::Actor > *result = 0 ;
94595
94596   arg1 = (int)jarg1;
94597   {
94598     try {
94599       try {
94600         result = (std::vector< Dali::Actor > *)new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(arg1);
94601       }
94602       catch(std::out_of_range &_e) {
94603         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94604         return 0;
94605       }
94606
94607     } catch (std::out_of_range& e) {
94608       {
94609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94610       };
94611     } catch (std::exception& e) {
94612       {
94613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94614       };
94615     } catch (Dali::DaliException e) {
94616       {
94617         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94618       };
94619     } catch (...) {
94620       {
94621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94622       };
94623     }
94624   }
94625
94626   jresult = (void *)result;
94627   return jresult;
94628 }
94629
94630
94631 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitemcopy(void * jarg1, int jarg2) {
94632   void * jresult ;
94633   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94634   int arg2 ;
94635   Dali::Actor result;
94636
94637   arg1 = (std::vector< Dali::Actor > *)jarg1;
94638   arg2 = (int)jarg2;
94639   {
94640     try {
94641       try {
94642         result = std_vector_Sl_Dali_Actor_Sg__getitemcopy(arg1,arg2);
94643       }
94644       catch(std::out_of_range &_e) {
94645         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94646         return 0;
94647       }
94648
94649     } catch (std::out_of_range& e) {
94650       {
94651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94652       };
94653     } catch (std::exception& e) {
94654       {
94655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94656       };
94657     } catch (Dali::DaliException e) {
94658       {
94659         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94660       };
94661     } catch (...) {
94662       {
94663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94664       };
94665     }
94666   }
94667
94668   jresult = new Dali::Actor((const Dali::Actor &)result);
94669   return jresult;
94670 }
94671
94672
94673 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitem(void * jarg1, int jarg2) {
94674   void * jresult ;
94675   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94676   int arg2 ;
94677   Dali::Actor *result = 0 ;
94678
94679   arg1 = (std::vector< Dali::Actor > *)jarg1;
94680   arg2 = (int)jarg2;
94681   {
94682     try {
94683       try {
94684         result = (Dali::Actor *) &std_vector_Sl_Dali_Actor_Sg__getitem(arg1,arg2);
94685       }
94686       catch(std::out_of_range &_e) {
94687         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94688         return 0;
94689       }
94690
94691     } catch (std::out_of_range& e) {
94692       {
94693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94694       };
94695     } catch (std::exception& e) {
94696       {
94697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94698       };
94699     } catch (Dali::DaliException e) {
94700       {
94701         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94702       };
94703     } catch (...) {
94704       {
94705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94706       };
94707     }
94708   }
94709
94710   jresult = (void *)result;
94711   return jresult;
94712 }
94713
94714
94715 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
94716   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94717   int arg2 ;
94718   Dali::Actor *arg3 = 0 ;
94719
94720   arg1 = (std::vector< Dali::Actor > *)jarg1;
94721   arg2 = (int)jarg2;
94722   arg3 = (Dali::Actor *)jarg3;
94723   if (!arg3) {
94724     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
94725     return ;
94726   }
94727   {
94728     try {
94729       try {
94730         std_vector_Sl_Dali_Actor_Sg__setitem(arg1,arg2,(Dali::Actor const &)*arg3);
94731       }
94732       catch(std::out_of_range &_e) {
94733         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94734         return ;
94735       }
94736
94737     } catch (std::out_of_range& e) {
94738       {
94739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94740       };
94741     } catch (std::exception& e) {
94742       {
94743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94744       };
94745     } catch (Dali::DaliException e) {
94746       {
94747         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94748       };
94749     } catch (...) {
94750       {
94751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94752       };
94753     }
94754   }
94755
94756 }
94757
94758
94759 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_AddRange(void * jarg1, void * jarg2) {
94760   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94761   std::vector< Dali::Actor > *arg2 = 0 ;
94762
94763   arg1 = (std::vector< Dali::Actor > *)jarg1;
94764   arg2 = (std::vector< Dali::Actor > *)jarg2;
94765   if (!arg2) {
94766     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
94767     return ;
94768   }
94769   {
94770     try {
94771       std_vector_Sl_Dali_Actor_Sg__AddRange(arg1,(std::vector< Dali::Actor > const &)*arg2);
94772     } catch (std::out_of_range& e) {
94773       {
94774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94775       };
94776     } catch (std::exception& e) {
94777       {
94778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94779       };
94780     } catch (Dali::DaliException e) {
94781       {
94782         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94783       };
94784     } catch (...) {
94785       {
94786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94787       };
94788     }
94789   }
94790
94791 }
94792
94793
94794 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
94795   void * jresult ;
94796   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94797   int arg2 ;
94798   int arg3 ;
94799   std::vector< Dali::Actor > *result = 0 ;
94800
94801   arg1 = (std::vector< Dali::Actor > *)jarg1;
94802   arg2 = (int)jarg2;
94803   arg3 = (int)jarg3;
94804   {
94805     try {
94806       try {
94807         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__GetRange(arg1,arg2,arg3);
94808       }
94809       catch(std::out_of_range &_e) {
94810         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94811         return 0;
94812       }
94813       catch(std::invalid_argument &_e) {
94814         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
94815         return 0;
94816       }
94817
94818     } catch (std::out_of_range& e) {
94819       {
94820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94821       };
94822     } catch (std::exception& e) {
94823       {
94824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94825       };
94826     } catch (Dali::DaliException e) {
94827       {
94828         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94829       };
94830     } catch (...) {
94831       {
94832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94833       };
94834     }
94835   }
94836
94837   jresult = (void *)result;
94838   return jresult;
94839 }
94840
94841
94842 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
94843   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94844   int arg2 ;
94845   Dali::Actor *arg3 = 0 ;
94846
94847   arg1 = (std::vector< Dali::Actor > *)jarg1;
94848   arg2 = (int)jarg2;
94849   arg3 = (Dali::Actor *)jarg3;
94850   if (!arg3) {
94851     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
94852     return ;
94853   }
94854   {
94855     try {
94856       try {
94857         std_vector_Sl_Dali_Actor_Sg__Insert(arg1,arg2,(Dali::Actor const &)*arg3);
94858       }
94859       catch(std::out_of_range &_e) {
94860         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94861         return ;
94862       }
94863
94864     } catch (std::out_of_range& e) {
94865       {
94866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94867       };
94868     } catch (std::exception& e) {
94869       {
94870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94871       };
94872     } catch (Dali::DaliException e) {
94873       {
94874         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94875       };
94876     } catch (...) {
94877       {
94878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94879       };
94880     }
94881   }
94882
94883 }
94884
94885
94886 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
94887   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94888   int arg2 ;
94889   std::vector< Dali::Actor > *arg3 = 0 ;
94890
94891   arg1 = (std::vector< Dali::Actor > *)jarg1;
94892   arg2 = (int)jarg2;
94893   arg3 = (std::vector< Dali::Actor > *)jarg3;
94894   if (!arg3) {
94895     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
94896     return ;
94897   }
94898   {
94899     try {
94900       try {
94901         std_vector_Sl_Dali_Actor_Sg__InsertRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
94902       }
94903       catch(std::out_of_range &_e) {
94904         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94905         return ;
94906       }
94907
94908     } catch (std::out_of_range& e) {
94909       {
94910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94911       };
94912     } catch (std::exception& e) {
94913       {
94914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94915       };
94916     } catch (Dali::DaliException e) {
94917       {
94918         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94919       };
94920     } catch (...) {
94921       {
94922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94923       };
94924     }
94925   }
94926
94927 }
94928
94929
94930 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveAt(void * jarg1, int jarg2) {
94931   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94932   int arg2 ;
94933
94934   arg1 = (std::vector< Dali::Actor > *)jarg1;
94935   arg2 = (int)jarg2;
94936   {
94937     try {
94938       try {
94939         std_vector_Sl_Dali_Actor_Sg__RemoveAt(arg1,arg2);
94940       }
94941       catch(std::out_of_range &_e) {
94942         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94943         return ;
94944       }
94945
94946     } catch (std::out_of_range& e) {
94947       {
94948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94949       };
94950     } catch (std::exception& e) {
94951       {
94952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94953       };
94954     } catch (Dali::DaliException e) {
94955       {
94956         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94957       };
94958     } catch (...) {
94959       {
94960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94961       };
94962     }
94963   }
94964
94965 }
94966
94967
94968 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
94969   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94970   int arg2 ;
94971   int arg3 ;
94972
94973   arg1 = (std::vector< Dali::Actor > *)jarg1;
94974   arg2 = (int)jarg2;
94975   arg3 = (int)jarg3;
94976   {
94977     try {
94978       try {
94979         std_vector_Sl_Dali_Actor_Sg__RemoveRange(arg1,arg2,arg3);
94980       }
94981       catch(std::out_of_range &_e) {
94982         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94983         return ;
94984       }
94985       catch(std::invalid_argument &_e) {
94986         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
94987         return ;
94988       }
94989
94990     } catch (std::out_of_range& e) {
94991       {
94992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94993       };
94994     } catch (std::exception& e) {
94995       {
94996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94997       };
94998     } catch (Dali::DaliException e) {
94999       {
95000         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95001       };
95002     } catch (...) {
95003       {
95004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95005       };
95006     }
95007   }
95008
95009 }
95010
95011
95012 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_Repeat(void * jarg1, int jarg2) {
95013   void * jresult ;
95014   Dali::Actor *arg1 = 0 ;
95015   int arg2 ;
95016   std::vector< Dali::Actor > *result = 0 ;
95017
95018   arg1 = (Dali::Actor *)jarg1;
95019   if (!arg1) {
95020     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
95021     return 0;
95022   }
95023   arg2 = (int)jarg2;
95024   {
95025     try {
95026       try {
95027         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__Repeat((Dali::Actor const &)*arg1,arg2);
95028       }
95029       catch(std::out_of_range &_e) {
95030         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95031         return 0;
95032       }
95033
95034     } catch (std::out_of_range& e) {
95035       {
95036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95037       };
95038     } catch (std::exception& e) {
95039       {
95040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95041       };
95042     } catch (Dali::DaliException e) {
95043       {
95044         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95045       };
95046     } catch (...) {
95047       {
95048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95049       };
95050     }
95051   }
95052
95053   jresult = (void *)result;
95054   return jresult;
95055 }
95056
95057
95058 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_0(void * jarg1) {
95059   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95060
95061   arg1 = (std::vector< Dali::Actor > *)jarg1;
95062   {
95063     try {
95064       std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(arg1);
95065     } catch (std::out_of_range& e) {
95066       {
95067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95068       };
95069     } catch (std::exception& e) {
95070       {
95071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95072       };
95073     } catch (Dali::DaliException e) {
95074       {
95075         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95076       };
95077     } catch (...) {
95078       {
95079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95080       };
95081     }
95082   }
95083
95084 }
95085
95086
95087 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
95088   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95089   int arg2 ;
95090   int arg3 ;
95091
95092   arg1 = (std::vector< Dali::Actor > *)jarg1;
95093   arg2 = (int)jarg2;
95094   arg3 = (int)jarg3;
95095   {
95096     try {
95097       try {
95098         std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
95099       }
95100       catch(std::out_of_range &_e) {
95101         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95102         return ;
95103       }
95104       catch(std::invalid_argument &_e) {
95105         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
95106         return ;
95107       }
95108
95109     } catch (std::out_of_range& e) {
95110       {
95111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95112       };
95113     } catch (std::exception& e) {
95114       {
95115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95116       };
95117     } catch (Dali::DaliException e) {
95118       {
95119         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95120       };
95121     } catch (...) {
95122       {
95123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95124       };
95125     }
95126   }
95127
95128 }
95129
95130
95131 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
95132   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95133   int arg2 ;
95134   std::vector< Dali::Actor > *arg3 = 0 ;
95135
95136   arg1 = (std::vector< Dali::Actor > *)jarg1;
95137   arg2 = (int)jarg2;
95138   arg3 = (std::vector< Dali::Actor > *)jarg3;
95139   if (!arg3) {
95140     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
95141     return ;
95142   }
95143   {
95144     try {
95145       try {
95146         std_vector_Sl_Dali_Actor_Sg__SetRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
95147       }
95148       catch(std::out_of_range &_e) {
95149         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95150         return ;
95151       }
95152
95153     } catch (std::out_of_range& e) {
95154       {
95155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95156       };
95157     } catch (std::exception& e) {
95158       {
95159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95160       };
95161     } catch (Dali::DaliException e) {
95162       {
95163         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95164       };
95165     } catch (...) {
95166       {
95167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95168       };
95169     }
95170   }
95171
95172 }
95173
95174
95175 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorContainer(void * jarg1) {
95176   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95177
95178   arg1 = (std::vector< Dali::Actor > *)jarg1;
95179   {
95180     try {
95181       delete arg1;
95182     } catch (std::out_of_range& e) {
95183       {
95184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95185       };
95186     } catch (std::exception& e) {
95187       {
95188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95189       };
95190     } catch (Dali::DaliException e) {
95191       {
95192         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95193       };
95194     } catch (...) {
95195       {
95196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95197       };
95198     }
95199   }
95200
95201 }
95202
95203
95204 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Empty(void * jarg1) {
95205   unsigned int jresult ;
95206   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95207   bool result;
95208
95209   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95210   {
95211     try {
95212       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
95213     } catch (std::out_of_range& e) {
95214       {
95215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95216       };
95217     } catch (std::exception& e) {
95218       {
95219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95220       };
95221     } catch (Dali::DaliException e) {
95222       {
95223         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95224       };
95225     } catch (...) {
95226       {
95227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95228       };
95229     }
95230   }
95231
95232   jresult = result;
95233   return jresult;
95234 }
95235
95236
95237 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_GetConnectionCount(void * jarg1) {
95238   unsigned long jresult ;
95239   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95240   std::size_t result;
95241
95242   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95243   {
95244     try {
95245       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
95246     } catch (std::out_of_range& e) {
95247       {
95248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95249       };
95250     } catch (std::exception& e) {
95251       {
95252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95253       };
95254     } catch (Dali::DaliException e) {
95255       {
95256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95257       };
95258     } catch (...) {
95259       {
95260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95261       };
95262     }
95263   }
95264
95265   jresult = (unsigned long)result;
95266   return jresult;
95267 }
95268
95269
95270 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Connect(void * jarg1, void * jarg2) {
95271   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95272   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
95273
95274   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95275   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
95276   {
95277     try {
95278       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Connect(arg1,arg2);
95279     } catch (std::out_of_range& e) {
95280       {
95281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95282       };
95283     } catch (std::exception& e) {
95284       {
95285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95286       };
95287     } catch (Dali::DaliException e) {
95288       {
95289         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95290       };
95291     } catch (...) {
95292       {
95293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95294       };
95295     }
95296   }
95297
95298 }
95299
95300
95301 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Disconnect(void * jarg1, void * jarg2) {
95302   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95303   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
95304
95305   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95306   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
95307   {
95308     try {
95309       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Disconnect(arg1,arg2);
95310     } catch (std::out_of_range& e) {
95311       {
95312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95313       };
95314     } catch (std::exception& e) {
95315       {
95316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95317       };
95318     } catch (Dali::DaliException e) {
95319       {
95320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95321       };
95322     } catch (...) {
95323       {
95324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95325       };
95326     }
95327   }
95328
95329 }
95330
95331
95332 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Emit(void * jarg1, void * jarg2) {
95333   unsigned int jresult ;
95334   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95335   Dali::Toolkit::AccessibilityManager *arg2 = 0 ;
95336   bool result;
95337
95338   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95339   arg2 = (Dali::Toolkit::AccessibilityManager *)jarg2;
95340   if (!arg2) {
95341     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AccessibilityManager & type is null", 0);
95342     return 0;
95343   }
95344   {
95345     try {
95346       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Emit(arg1,*arg2);
95347     } catch (std::out_of_range& e) {
95348       {
95349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95350       };
95351     } catch (std::exception& e) {
95352       {
95353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95354       };
95355     } catch (Dali::DaliException e) {
95356       {
95357         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95358       };
95359     } catch (...) {
95360       {
95361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95362       };
95363     }
95364   }
95365
95366   jresult = result;
95367   return jresult;
95368 }
95369
95370
95371 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityActionSignal() {
95372   void * jresult ;
95373   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *result = 0 ;
95374
95375   {
95376     try {
95377       result = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)new Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) >();
95378     } catch (std::out_of_range& e) {
95379       {
95380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95381       };
95382     } catch (std::exception& e) {
95383       {
95384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95385       };
95386     } catch (Dali::DaliException e) {
95387       {
95388         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95389       };
95390     } catch (...) {
95391       {
95392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95393       };
95394     }
95395   }
95396
95397   jresult = (void *)result;
95398   return jresult;
95399 }
95400
95401
95402 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityActionSignal(void * jarg1) {
95403   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95404
95405   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95406   {
95407     try {
95408       delete arg1;
95409     } catch (std::out_of_range& e) {
95410       {
95411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95412       };
95413     } catch (std::exception& e) {
95414       {
95415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95416       };
95417     } catch (Dali::DaliException e) {
95418       {
95419         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95420       };
95421     } catch (...) {
95422       {
95423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95424       };
95425     }
95426   }
95427
95428 }
95429
95430
95431 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Empty(void * jarg1) {
95432   unsigned int jresult ;
95433   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
95434   bool result;
95435
95436   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
95437   {
95438     try {
95439       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);
95440     } catch (std::out_of_range& e) {
95441       {
95442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95443       };
95444     } catch (std::exception& e) {
95445       {
95446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95447       };
95448     } catch (Dali::DaliException e) {
95449       {
95450         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95451       };
95452     } catch (...) {
95453       {
95454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95455       };
95456     }
95457   }
95458
95459   jresult = result;
95460   return jresult;
95461 }
95462
95463
95464 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_GetConnectionCount(void * jarg1) {
95465   unsigned long jresult ;
95466   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
95467   std::size_t result;
95468
95469   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
95470   {
95471     try {
95472       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);
95473     } catch (std::out_of_range& e) {
95474       {
95475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95476       };
95477     } catch (std::exception& e) {
95478       {
95479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95480       };
95481     } catch (Dali::DaliException e) {
95482       {
95483         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95484       };
95485     } catch (...) {
95486       {
95487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95488       };
95489     }
95490   }
95491
95492   jresult = (unsigned long)result;
95493   return jresult;
95494 }
95495
95496
95497 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Connect(void * jarg1, void * jarg2) {
95498   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
95499   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
95500
95501   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
95502   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
95503   {
95504     try {
95505       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Connect(arg1,arg2);
95506     } catch (std::out_of_range& e) {
95507       {
95508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95509       };
95510     } catch (std::exception& e) {
95511       {
95512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95513       };
95514     } catch (Dali::DaliException e) {
95515       {
95516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95517       };
95518     } catch (...) {
95519       {
95520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95521       };
95522     }
95523   }
95524
95525 }
95526
95527
95528 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Disconnect(void * jarg1, void * jarg2) {
95529   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
95530   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
95531
95532   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
95533   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
95534   {
95535     try {
95536       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Disconnect(arg1,arg2);
95537     } catch (std::out_of_range& e) {
95538       {
95539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95540       };
95541     } catch (std::exception& e) {
95542       {
95543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95544       };
95545     } catch (Dali::DaliException e) {
95546       {
95547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95548       };
95549     } catch (...) {
95550       {
95551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95552       };
95553     }
95554   }
95555
95556 }
95557
95558
95559 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
95560   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
95561   Dali::Actor arg2 ;
95562   Dali::Toolkit::AccessibilityManager::FocusOvershotDirection arg3 ;
95563   Dali::Actor *argp2 ;
95564
95565   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
95566   argp2 = (Dali::Actor *)jarg2;
95567   if (!argp2) {
95568     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
95569     return ;
95570   }
95571   arg2 = *argp2;
95572   arg3 = (Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)jarg3;
95573   {
95574     try {
95575       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Emit(arg1,arg2,arg3);
95576     } catch (std::out_of_range& e) {
95577       {
95578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95579       };
95580     } catch (std::exception& e) {
95581       {
95582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95583       };
95584     } catch (Dali::DaliException e) {
95585       {
95586         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95587       };
95588     } catch (...) {
95589       {
95590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95591       };
95592     }
95593   }
95594
95595 }
95596
95597
95598 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityFocusOvershotSignal() {
95599   void * jresult ;
95600   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *result = 0 ;
95601
95602   {
95603     try {
95604       result = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)new Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) >();
95605     } catch (std::out_of_range& e) {
95606       {
95607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95608       };
95609     } catch (std::exception& e) {
95610       {
95611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95612       };
95613     } catch (Dali::DaliException e) {
95614       {
95615         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95616       };
95617     } catch (...) {
95618       {
95619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95620       };
95621     }
95622   }
95623
95624   jresult = (void *)result;
95625   return jresult;
95626 }
95627
95628
95629 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityFocusOvershotSignal(void * jarg1) {
95630   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
95631
95632   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
95633   {
95634     try {
95635       delete arg1;
95636     } catch (std::out_of_range& e) {
95637       {
95638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95639       };
95640     } catch (std::exception& e) {
95641       {
95642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95643       };
95644     } catch (Dali::DaliException e) {
95645       {
95646         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95647       };
95648     } catch (...) {
95649       {
95650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95651       };
95652     }
95653   }
95654
95655 }
95656
95657
95658 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Empty(void * jarg1) {
95659   unsigned int jresult ;
95660   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
95661   bool result;
95662
95663   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
95664   {
95665     try {
95666       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
95667     } catch (std::out_of_range& e) {
95668       {
95669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95670       };
95671     } catch (std::exception& e) {
95672       {
95673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95674       };
95675     } catch (Dali::DaliException e) {
95676       {
95677         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95678       };
95679     } catch (...) {
95680       {
95681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95682       };
95683     }
95684   }
95685
95686   jresult = result;
95687   return jresult;
95688 }
95689
95690
95691 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusChangedSignal_GetConnectionCount(void * jarg1) {
95692   unsigned long jresult ;
95693   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
95694   std::size_t result;
95695
95696   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
95697   {
95698     try {
95699       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
95700     } catch (std::out_of_range& e) {
95701       {
95702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95703       };
95704     } catch (std::exception& e) {
95705       {
95706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95707       };
95708     } catch (Dali::DaliException e) {
95709       {
95710         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95711       };
95712     } catch (...) {
95713       {
95714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95715       };
95716     }
95717   }
95718
95719   jresult = (unsigned long)result;
95720   return jresult;
95721 }
95722
95723
95724 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Connect(void * jarg1, void * jarg2) {
95725   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
95726   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
95727
95728   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
95729   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
95730   {
95731     try {
95732       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Connect(arg1,arg2);
95733     } catch (std::out_of_range& e) {
95734       {
95735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95736       };
95737     } catch (std::exception& e) {
95738       {
95739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95740       };
95741     } catch (Dali::DaliException e) {
95742       {
95743         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95744       };
95745     } catch (...) {
95746       {
95747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95748       };
95749     }
95750   }
95751
95752 }
95753
95754
95755 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Disconnect(void * jarg1, void * jarg2) {
95756   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
95757   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
95758
95759   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
95760   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
95761   {
95762     try {
95763       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
95764     } catch (std::out_of_range& e) {
95765       {
95766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95767       };
95768     } catch (std::exception& e) {
95769       {
95770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95771       };
95772     } catch (Dali::DaliException e) {
95773       {
95774         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95775       };
95776     } catch (...) {
95777       {
95778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95779       };
95780     }
95781   }
95782
95783 }
95784
95785
95786 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
95787   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
95788   Dali::Actor arg2 ;
95789   Dali::Actor arg3 ;
95790   Dali::Actor *argp2 ;
95791   Dali::Actor *argp3 ;
95792
95793   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
95794   argp2 = (Dali::Actor *)jarg2;
95795   if (!argp2) {
95796     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
95797     return ;
95798   }
95799   arg2 = *argp2;
95800   argp3 = (Dali::Actor *)jarg3;
95801   if (!argp3) {
95802     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
95803     return ;
95804   }
95805   arg3 = *argp3;
95806   {
95807     try {
95808       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Emit(arg1,arg2,arg3);
95809     } catch (std::out_of_range& e) {
95810       {
95811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95812       };
95813     } catch (std::exception& e) {
95814       {
95815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95816       };
95817     } catch (Dali::DaliException e) {
95818       {
95819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95820       };
95821     } catch (...) {
95822       {
95823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95824       };
95825     }
95826   }
95827
95828 }
95829
95830
95831 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusChangedSignal() {
95832   void * jresult ;
95833   Dali::Signal< void (Dali::Actor,Dali::Actor) > *result = 0 ;
95834
95835   {
95836     try {
95837       result = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)new Dali::Signal< void (Dali::Actor,Dali::Actor) >();
95838     } catch (std::out_of_range& e) {
95839       {
95840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95841       };
95842     } catch (std::exception& e) {
95843       {
95844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95845       };
95846     } catch (Dali::DaliException e) {
95847       {
95848         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95849       };
95850     } catch (...) {
95851       {
95852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95853       };
95854     }
95855   }
95856
95857   jresult = (void *)result;
95858   return jresult;
95859 }
95860
95861
95862 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusChangedSignal(void * jarg1) {
95863   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
95864
95865   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
95866   {
95867     try {
95868       delete arg1;
95869     } catch (std::out_of_range& e) {
95870       {
95871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95872       };
95873     } catch (std::exception& e) {
95874       {
95875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95876       };
95877     } catch (Dali::DaliException e) {
95878       {
95879         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95880       };
95881     } catch (...) {
95882       {
95883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95884       };
95885     }
95886   }
95887
95888 }
95889
95890
95891 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Empty(void * jarg1) {
95892   unsigned int jresult ;
95893   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
95894   bool result;
95895
95896   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
95897   {
95898     try {
95899       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
95900     } catch (std::out_of_range& e) {
95901       {
95902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95903       };
95904     } catch (std::exception& e) {
95905       {
95906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95907       };
95908     } catch (Dali::DaliException e) {
95909       {
95910         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95911       };
95912     } catch (...) {
95913       {
95914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95915       };
95916     }
95917   }
95918
95919   jresult = result;
95920   return jresult;
95921 }
95922
95923
95924 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_GetConnectionCount(void * jarg1) {
95925   unsigned long jresult ;
95926   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
95927   std::size_t result;
95928
95929   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
95930   {
95931     try {
95932       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
95933     } catch (std::out_of_range& e) {
95934       {
95935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95936       };
95937     } catch (std::exception& e) {
95938       {
95939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95940       };
95941     } catch (Dali::DaliException e) {
95942       {
95943         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95944       };
95945     } catch (...) {
95946       {
95947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95948       };
95949     }
95950   }
95951
95952   jresult = (unsigned long)result;
95953   return jresult;
95954 }
95955
95956
95957 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Connect(void * jarg1, void * jarg2) {
95958   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
95959   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
95960
95961   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
95962   arg2 = (void (*)(Dali::Actor,bool))jarg2;
95963   {
95964     try {
95965       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Connect(arg1,arg2);
95966     } catch (std::out_of_range& e) {
95967       {
95968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95969       };
95970     } catch (std::exception& e) {
95971       {
95972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95973       };
95974     } catch (Dali::DaliException e) {
95975       {
95976         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95977       };
95978     } catch (...) {
95979       {
95980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95981       };
95982     }
95983   }
95984
95985 }
95986
95987
95988 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Disconnect(void * jarg1, void * jarg2) {
95989   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
95990   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
95991
95992   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
95993   arg2 = (void (*)(Dali::Actor,bool))jarg2;
95994   {
95995     try {
95996       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
95997     } catch (std::out_of_range& e) {
95998       {
95999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96000       };
96001     } catch (std::exception& e) {
96002       {
96003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96004       };
96005     } catch (Dali::DaliException e) {
96006       {
96007         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96008       };
96009     } catch (...) {
96010       {
96011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96012       };
96013     }
96014   }
96015
96016 }
96017
96018
96019 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3) {
96020   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
96021   Dali::Actor arg2 ;
96022   bool arg3 ;
96023   Dali::Actor *argp2 ;
96024
96025   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
96026   argp2 = (Dali::Actor *)jarg2;
96027   if (!argp2) {
96028     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
96029     return ;
96030   }
96031   arg2 = *argp2;
96032   arg3 = jarg3 ? true : false;
96033   {
96034     try {
96035       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3);
96036     } catch (std::out_of_range& e) {
96037       {
96038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96039       };
96040     } catch (std::exception& e) {
96041       {
96042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96043       };
96044     } catch (Dali::DaliException e) {
96045       {
96046         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96047       };
96048     } catch (...) {
96049       {
96050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96051       };
96052     }
96053   }
96054
96055 }
96056
96057
96058 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusGroupChangedSignal() {
96059   void * jresult ;
96060   Dali::Signal< void (Dali::Actor,bool) > *result = 0 ;
96061
96062   {
96063     try {
96064       result = (Dali::Signal< void (Dali::Actor,bool) > *)new Dali::Signal< void (Dali::Actor,bool) >();
96065     } catch (std::out_of_range& e) {
96066       {
96067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96068       };
96069     } catch (std::exception& e) {
96070       {
96071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96072       };
96073     } catch (Dali::DaliException e) {
96074       {
96075         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96076       };
96077     } catch (...) {
96078       {
96079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96080       };
96081     }
96082   }
96083
96084   jresult = (void *)result;
96085   return jresult;
96086 }
96087
96088
96089 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusGroupChangedSignal(void * jarg1) {
96090   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
96091
96092   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
96093   {
96094     try {
96095       delete arg1;
96096     } catch (std::out_of_range& e) {
96097       {
96098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96099       };
96100     } catch (std::exception& e) {
96101       {
96102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96103       };
96104     } catch (Dali::DaliException e) {
96105       {
96106         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96107       };
96108     } catch (...) {
96109       {
96110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96111       };
96112     }
96113   }
96114
96115 }
96116
96117
96118 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Empty(void * jarg1) {
96119   unsigned int jresult ;
96120   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96121   bool result;
96122
96123   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96124   {
96125     try {
96126       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);
96127     } catch (std::out_of_range& e) {
96128       {
96129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96130       };
96131     } catch (std::exception& e) {
96132       {
96133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96134       };
96135     } catch (Dali::DaliException e) {
96136       {
96137         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96138       };
96139     } catch (...) {
96140       {
96141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96142       };
96143     }
96144   }
96145
96146   jresult = result;
96147   return jresult;
96148 }
96149
96150
96151 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StyleChangedSignal_GetConnectionCount(void * jarg1) {
96152   unsigned long jresult ;
96153   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96154   std::size_t result;
96155
96156   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96157   {
96158     try {
96159       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);
96160     } catch (std::out_of_range& e) {
96161       {
96162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96163       };
96164     } catch (std::exception& e) {
96165       {
96166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96167       };
96168     } catch (Dali::DaliException e) {
96169       {
96170         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96171       };
96172     } catch (...) {
96173       {
96174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96175       };
96176     }
96177   }
96178
96179   jresult = (unsigned long)result;
96180   return jresult;
96181 }
96182
96183
96184 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Connect(void * jarg1, void * jarg2) {
96185   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96186   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
96187
96188   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96189   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
96190   {
96191     try {
96192       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Connect(arg1,arg2);
96193     } catch (std::out_of_range& e) {
96194       {
96195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96196       };
96197     } catch (std::exception& e) {
96198       {
96199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96200       };
96201     } catch (Dali::DaliException e) {
96202       {
96203         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96204       };
96205     } catch (...) {
96206       {
96207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96208       };
96209     }
96210   }
96211
96212 }
96213
96214
96215 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Disconnect(void * jarg1, void * jarg2) {
96216   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96217   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
96218
96219   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96220   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
96221   {
96222     try {
96223       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Disconnect(arg1,arg2);
96224     } catch (std::out_of_range& e) {
96225       {
96226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96227       };
96228     } catch (std::exception& e) {
96229       {
96230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96231       };
96232     } catch (Dali::DaliException e) {
96233       {
96234         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96235       };
96236     } catch (...) {
96237       {
96238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96239       };
96240     }
96241   }
96242
96243 }
96244
96245
96246 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
96247   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96248   Dali::Toolkit::StyleManager arg2 ;
96249   Dali::StyleChange::Type arg3 ;
96250   Dali::Toolkit::StyleManager *argp2 ;
96251
96252   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96253   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
96254   if (!argp2) {
96255     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
96256     return ;
96257   }
96258   arg2 = *argp2;
96259   arg3 = (Dali::StyleChange::Type)jarg3;
96260   {
96261     try {
96262       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Emit(arg1,arg2,arg3);
96263     } catch (std::out_of_range& e) {
96264       {
96265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96266       };
96267     } catch (std::exception& e) {
96268       {
96269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96270       };
96271     } catch (Dali::DaliException e) {
96272       {
96273         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96274       };
96275     } catch (...) {
96276       {
96277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96278       };
96279     }
96280   }
96281
96282 }
96283
96284
96285 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleChangedSignal() {
96286   void * jresult ;
96287   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *result = 0 ;
96288
96289   {
96290     try {
96291       result = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)new Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) >();
96292     } catch (std::out_of_range& e) {
96293       {
96294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96295       };
96296     } catch (std::exception& e) {
96297       {
96298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96299       };
96300     } catch (Dali::DaliException e) {
96301       {
96302         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96303       };
96304     } catch (...) {
96305       {
96306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96307       };
96308     }
96309   }
96310
96311   jresult = (void *)result;
96312   return jresult;
96313 }
96314
96315
96316 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleChangedSignal(void * jarg1) {
96317   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96318
96319   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96320   {
96321     try {
96322       delete arg1;
96323     } catch (std::out_of_range& e) {
96324       {
96325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96326       };
96327     } catch (std::exception& e) {
96328       {
96329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96330       };
96331     } catch (Dali::DaliException e) {
96332       {
96333         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96334       };
96335     } catch (...) {
96336       {
96337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96338       };
96339     }
96340   }
96341
96342 }
96343
96344
96345 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Empty(void * jarg1) {
96346   unsigned int jresult ;
96347   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96348   bool result;
96349
96350   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96351   {
96352     try {
96353       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
96354     } catch (std::out_of_range& e) {
96355       {
96356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96357       };
96358     } catch (std::exception& e) {
96359       {
96360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96361       };
96362     } catch (Dali::DaliException e) {
96363       {
96364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96365       };
96366     } catch (...) {
96367       {
96368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96369       };
96370     }
96371   }
96372
96373   jresult = result;
96374   return jresult;
96375 }
96376
96377
96378 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ButtonSignal_GetConnectionCount(void * jarg1) {
96379   unsigned long jresult ;
96380   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96381   std::size_t result;
96382
96383   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96384   {
96385     try {
96386       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
96387     } catch (std::out_of_range& e) {
96388       {
96389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96390       };
96391     } catch (std::exception& e) {
96392       {
96393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96394       };
96395     } catch (Dali::DaliException e) {
96396       {
96397         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96398       };
96399     } catch (...) {
96400       {
96401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96402       };
96403     }
96404   }
96405
96406   jresult = (unsigned long)result;
96407   return jresult;
96408 }
96409
96410
96411 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Connect(void * jarg1, void * jarg2) {
96412   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96413   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
96414
96415   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96416   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
96417   {
96418     try {
96419       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Connect(arg1,arg2);
96420     } catch (std::out_of_range& e) {
96421       {
96422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96423       };
96424     } catch (std::exception& e) {
96425       {
96426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96427       };
96428     } catch (Dali::DaliException e) {
96429       {
96430         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96431       };
96432     } catch (...) {
96433       {
96434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96435       };
96436     }
96437   }
96438
96439 }
96440
96441
96442 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Disconnect(void * jarg1, void * jarg2) {
96443   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96444   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
96445
96446   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96447   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
96448   {
96449     try {
96450       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Disconnect(arg1,arg2);
96451     } catch (std::out_of_range& e) {
96452       {
96453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96454       };
96455     } catch (std::exception& e) {
96456       {
96457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96458       };
96459     } catch (Dali::DaliException e) {
96460       {
96461         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96462       };
96463     } catch (...) {
96464       {
96465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96466       };
96467     }
96468   }
96469
96470 }
96471
96472
96473 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Emit(void * jarg1, void * jarg2) {
96474   unsigned int jresult ;
96475   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96476   Dali::Toolkit::Button arg2 ;
96477   Dali::Toolkit::Button *argp2 ;
96478   bool result;
96479
96480   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96481   argp2 = (Dali::Toolkit::Button *)jarg2;
96482   if (!argp2) {
96483     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Button", 0);
96484     return 0;
96485   }
96486   arg2 = *argp2;
96487   {
96488     try {
96489       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(arg1,arg2);
96490     } catch (std::out_of_range& e) {
96491       {
96492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96493       };
96494     } catch (std::exception& e) {
96495       {
96496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96497       };
96498     } catch (Dali::DaliException e) {
96499       {
96500         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96501       };
96502     } catch (...) {
96503       {
96504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96505       };
96506     }
96507   }
96508
96509   jresult = result;
96510   return jresult;
96511 }
96512
96513
96514 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ButtonSignal() {
96515   void * jresult ;
96516   Dali::Signal< bool (Dali::Toolkit::Button) > *result = 0 ;
96517
96518   {
96519     try {
96520       result = (Dali::Signal< bool (Dali::Toolkit::Button) > *)new Dali::Signal< bool (Dali::Toolkit::Button) >();
96521     } catch (std::out_of_range& e) {
96522       {
96523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96524       };
96525     } catch (std::exception& e) {
96526       {
96527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96528       };
96529     } catch (Dali::DaliException e) {
96530       {
96531         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96532       };
96533     } catch (...) {
96534       {
96535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96536       };
96537     }
96538   }
96539
96540   jresult = (void *)result;
96541   return jresult;
96542 }
96543
96544
96545 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ButtonSignal(void * jarg1) {
96546   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96547
96548   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96549   {
96550     try {
96551       delete arg1;
96552     } catch (std::out_of_range& e) {
96553       {
96554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96555       };
96556     } catch (std::exception& e) {
96557       {
96558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96559       };
96560     } catch (Dali::DaliException e) {
96561       {
96562         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96563       };
96564     } catch (...) {
96565       {
96566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96567       };
96568     }
96569   }
96570
96571 }
96572
96573
96574 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Empty(void * jarg1) {
96575   unsigned int jresult ;
96576   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
96577   bool result;
96578
96579   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
96580   {
96581     try {
96582       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
96583     } catch (std::out_of_range& e) {
96584       {
96585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96586       };
96587     } catch (std::exception& e) {
96588       {
96589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96590       };
96591     } catch (Dali::DaliException e) {
96592       {
96593         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96594       };
96595     } catch (...) {
96596       {
96597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96598       };
96599     }
96600   }
96601
96602   jresult = result;
96603   return jresult;
96604 }
96605
96606
96607 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_GetConnectionCount(void * jarg1) {
96608   unsigned long jresult ;
96609   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
96610   std::size_t result;
96611
96612   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
96613   {
96614     try {
96615       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
96616     } catch (std::out_of_range& e) {
96617       {
96618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96619       };
96620     } catch (std::exception& e) {
96621       {
96622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96623       };
96624     } catch (Dali::DaliException e) {
96625       {
96626         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96627       };
96628     } catch (...) {
96629       {
96630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96631       };
96632     }
96633   }
96634
96635   jresult = (unsigned long)result;
96636   return jresult;
96637 }
96638
96639
96640 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Connect(void * jarg1, void * jarg2) {
96641   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
96642   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
96643
96644   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
96645   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
96646   {
96647     try {
96648       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Connect(arg1,arg2);
96649     } catch (std::out_of_range& e) {
96650       {
96651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96652       };
96653     } catch (std::exception& e) {
96654       {
96655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96656       };
96657     } catch (Dali::DaliException e) {
96658       {
96659         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96660       };
96661     } catch (...) {
96662       {
96663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96664       };
96665     }
96666   }
96667
96668 }
96669
96670
96671 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Disconnect(void * jarg1, void * jarg2) {
96672   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
96673   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
96674
96675   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
96676   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
96677   {
96678     try {
96679       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Disconnect(arg1,arg2);
96680     } catch (std::out_of_range& e) {
96681       {
96682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96683       };
96684     } catch (std::exception& e) {
96685       {
96686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96687       };
96688     } catch (Dali::DaliException e) {
96689       {
96690         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96691       };
96692     } catch (...) {
96693       {
96694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96695       };
96696     }
96697   }
96698
96699 }
96700
96701
96702 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Emit(void * jarg1, void * jarg2) {
96703   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
96704   Dali::Toolkit::GaussianBlurView arg2 ;
96705   Dali::Toolkit::GaussianBlurView *argp2 ;
96706
96707   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
96708   argp2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
96709   if (!argp2) {
96710     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::GaussianBlurView", 0);
96711     return ;
96712   }
96713   arg2 = *argp2;
96714   {
96715     try {
96716       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(arg1,arg2);
96717     } catch (std::out_of_range& e) {
96718       {
96719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96720       };
96721     } catch (std::exception& e) {
96722       {
96723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96724       };
96725     } catch (Dali::DaliException e) {
96726       {
96727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96728       };
96729     } catch (...) {
96730       {
96731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96732       };
96733     }
96734   }
96735
96736 }
96737
96738
96739 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurViewSignal() {
96740   void * jresult ;
96741   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *result = 0 ;
96742
96743   {
96744     try {
96745       result = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)new Dali::Signal< void (Dali::Toolkit::GaussianBlurView) >();
96746     } catch (std::out_of_range& e) {
96747       {
96748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96749       };
96750     } catch (std::exception& e) {
96751       {
96752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96753       };
96754     } catch (Dali::DaliException e) {
96755       {
96756         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96757       };
96758     } catch (...) {
96759       {
96760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96761       };
96762     }
96763   }
96764
96765   jresult = (void *)result;
96766   return jresult;
96767 }
96768
96769
96770 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurViewSignal(void * jarg1) {
96771   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
96772
96773   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
96774   {
96775     try {
96776       delete arg1;
96777     } catch (std::out_of_range& e) {
96778       {
96779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96780       };
96781     } catch (std::exception& e) {
96782       {
96783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96784       };
96785     } catch (Dali::DaliException e) {
96786       {
96787         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96788       };
96789     } catch (...) {
96790       {
96791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96792       };
96793     }
96794   }
96795
96796 }
96797
96798
96799 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageTurnSignal_Empty(void * jarg1) {
96800   unsigned int jresult ;
96801   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
96802   bool result;
96803
96804   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
96805   {
96806     try {
96807       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);
96808     } catch (std::out_of_range& e) {
96809       {
96810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96811       };
96812     } catch (std::exception& e) {
96813       {
96814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96815       };
96816     } catch (Dali::DaliException e) {
96817       {
96818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96819       };
96820     } catch (...) {
96821       {
96822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96823       };
96824     }
96825   }
96826
96827   jresult = result;
96828   return jresult;
96829 }
96830
96831
96832 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PageTurnSignal_GetConnectionCount(void * jarg1) {
96833   unsigned long jresult ;
96834   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
96835   std::size_t result;
96836
96837   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
96838   {
96839     try {
96840       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);
96841     } catch (std::out_of_range& e) {
96842       {
96843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96844       };
96845     } catch (std::exception& e) {
96846       {
96847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96848       };
96849     } catch (Dali::DaliException e) {
96850       {
96851         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96852       };
96853     } catch (...) {
96854       {
96855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96856       };
96857     }
96858   }
96859
96860   jresult = (unsigned long)result;
96861   return jresult;
96862 }
96863
96864
96865 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Connect(void * jarg1, void * jarg2) {
96866   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
96867   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
96868
96869   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
96870   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
96871   {
96872     try {
96873       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Connect(arg1,arg2);
96874     } catch (std::out_of_range& e) {
96875       {
96876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96877       };
96878     } catch (std::exception& e) {
96879       {
96880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96881       };
96882     } catch (Dali::DaliException e) {
96883       {
96884         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96885       };
96886     } catch (...) {
96887       {
96888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96889       };
96890     }
96891   }
96892
96893 }
96894
96895
96896 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Disconnect(void * jarg1, void * jarg2) {
96897   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
96898   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
96899
96900   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
96901   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
96902   {
96903     try {
96904       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
96905     } catch (std::out_of_range& e) {
96906       {
96907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96908       };
96909     } catch (std::exception& e) {
96910       {
96911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96912       };
96913     } catch (Dali::DaliException e) {
96914       {
96915         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96916       };
96917     } catch (...) {
96918       {
96919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96920       };
96921     }
96922   }
96923
96924 }
96925
96926
96927 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
96928   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
96929   Dali::Toolkit::PageTurnView arg2 ;
96930   unsigned int arg3 ;
96931   bool arg4 ;
96932   Dali::Toolkit::PageTurnView *argp2 ;
96933
96934   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
96935   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
96936   if (!argp2) {
96937     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
96938     return ;
96939   }
96940   arg2 = *argp2;
96941   arg3 = (unsigned int)jarg3;
96942   arg4 = jarg4 ? true : false;
96943   {
96944     try {
96945       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3,arg4);
96946     } catch (std::out_of_range& e) {
96947       {
96948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96949       };
96950     } catch (std::exception& e) {
96951       {
96952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96953       };
96954     } catch (Dali::DaliException e) {
96955       {
96956         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96957       };
96958     } catch (...) {
96959       {
96960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96961       };
96962     }
96963   }
96964
96965 }
96966
96967
96968 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnSignal() {
96969   void * jresult ;
96970   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *result = 0 ;
96971
96972   {
96973     try {
96974       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) >();
96975     } catch (std::out_of_range& e) {
96976       {
96977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96978       };
96979     } catch (std::exception& e) {
96980       {
96981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96982       };
96983     } catch (Dali::DaliException e) {
96984       {
96985         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96986       };
96987     } catch (...) {
96988       {
96989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96990       };
96991     }
96992   }
96993
96994   jresult = (void *)result;
96995   return jresult;
96996 }
96997
96998
96999 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnSignal(void * jarg1) {
97000   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
97001
97002   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
97003   {
97004     try {
97005       delete arg1;
97006     } catch (std::out_of_range& e) {
97007       {
97008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97009       };
97010     } catch (std::exception& e) {
97011       {
97012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97013       };
97014     } catch (Dali::DaliException e) {
97015       {
97016         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97017       };
97018     } catch (...) {
97019       {
97020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97021       };
97022     }
97023   }
97024
97025 }
97026
97027
97028 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PagePanSignal_Empty(void * jarg1) {
97029   unsigned int jresult ;
97030   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97031   bool result;
97032
97033   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97034   {
97035     try {
97036       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
97037     } catch (std::out_of_range& e) {
97038       {
97039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97040       };
97041     } catch (std::exception& e) {
97042       {
97043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97044       };
97045     } catch (Dali::DaliException e) {
97046       {
97047         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97048       };
97049     } catch (...) {
97050       {
97051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97052       };
97053     }
97054   }
97055
97056   jresult = result;
97057   return jresult;
97058 }
97059
97060
97061 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PagePanSignal_GetConnectionCount(void * jarg1) {
97062   unsigned long jresult ;
97063   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97064   std::size_t result;
97065
97066   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97067   {
97068     try {
97069       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
97070     } catch (std::out_of_range& e) {
97071       {
97072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97073       };
97074     } catch (std::exception& e) {
97075       {
97076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97077       };
97078     } catch (Dali::DaliException e) {
97079       {
97080         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97081       };
97082     } catch (...) {
97083       {
97084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97085       };
97086     }
97087   }
97088
97089   jresult = (unsigned long)result;
97090   return jresult;
97091 }
97092
97093
97094 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Connect(void * jarg1, void * jarg2) {
97095   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97096   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
97097
97098   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97099   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
97100   {
97101     try {
97102       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Connect(arg1,arg2);
97103     } catch (std::out_of_range& e) {
97104       {
97105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97106       };
97107     } catch (std::exception& e) {
97108       {
97109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97110       };
97111     } catch (Dali::DaliException e) {
97112       {
97113         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97114       };
97115     } catch (...) {
97116       {
97117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97118       };
97119     }
97120   }
97121
97122 }
97123
97124
97125 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Disconnect(void * jarg1, void * jarg2) {
97126   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97127   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
97128
97129   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97130   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
97131   {
97132     try {
97133       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Disconnect(arg1,arg2);
97134     } catch (std::out_of_range& e) {
97135       {
97136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97137       };
97138     } catch (std::exception& e) {
97139       {
97140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97141       };
97142     } catch (Dali::DaliException e) {
97143       {
97144         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97145       };
97146     } catch (...) {
97147       {
97148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97149       };
97150     }
97151   }
97152
97153 }
97154
97155
97156 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Emit(void * jarg1, void * jarg2) {
97157   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97158   Dali::Toolkit::PageTurnView arg2 ;
97159   Dali::Toolkit::PageTurnView *argp2 ;
97160
97161   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97162   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
97163   if (!argp2) {
97164     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
97165     return ;
97166   }
97167   arg2 = *argp2;
97168   {
97169     try {
97170       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(arg1,arg2);
97171     } catch (std::out_of_range& e) {
97172       {
97173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97174       };
97175     } catch (std::exception& e) {
97176       {
97177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97178       };
97179     } catch (Dali::DaliException e) {
97180       {
97181         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97182       };
97183     } catch (...) {
97184       {
97185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97186       };
97187     }
97188   }
97189
97190 }
97191
97192
97193 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PagePanSignal() {
97194   void * jresult ;
97195   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *result = 0 ;
97196
97197   {
97198     try {
97199       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView) >();
97200     } catch (std::out_of_range& e) {
97201       {
97202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97203       };
97204     } catch (std::exception& e) {
97205       {
97206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97207       };
97208     } catch (Dali::DaliException e) {
97209       {
97210         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97211       };
97212     } catch (...) {
97213       {
97214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97215       };
97216     }
97217   }
97218
97219   jresult = (void *)result;
97220   return jresult;
97221 }
97222
97223
97224 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PagePanSignal(void * jarg1) {
97225   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97226
97227   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97228   {
97229     try {
97230       delete arg1;
97231     } catch (std::out_of_range& e) {
97232       {
97233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97234       };
97235     } catch (std::exception& e) {
97236       {
97237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97238       };
97239     } catch (Dali::DaliException e) {
97240       {
97241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97242       };
97243     } catch (...) {
97244       {
97245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97246       };
97247     }
97248   }
97249
97250 }
97251
97252
97253 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Empty(void * jarg1) {
97254   unsigned int jresult ;
97255   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97256   bool result;
97257
97258   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97259   {
97260     try {
97261       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);
97262     } catch (std::out_of_range& e) {
97263       {
97264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97265       };
97266     } catch (std::exception& e) {
97267       {
97268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97269       };
97270     } catch (Dali::DaliException e) {
97271       {
97272         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97273       };
97274     } catch (...) {
97275       {
97276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97277       };
97278     }
97279   }
97280
97281   jresult = result;
97282   return jresult;
97283 }
97284
97285
97286 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_GetConnectionCount(void * jarg1) {
97287   unsigned long jresult ;
97288   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97289   std::size_t result;
97290
97291   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97292   {
97293     try {
97294       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);
97295     } catch (std::out_of_range& e) {
97296       {
97297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97298       };
97299     } catch (std::exception& e) {
97300       {
97301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97302       };
97303     } catch (Dali::DaliException e) {
97304       {
97305         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97306       };
97307     } catch (...) {
97308       {
97309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97310       };
97311     }
97312   }
97313
97314   jresult = (unsigned long)result;
97315   return jresult;
97316 }
97317
97318
97319 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Connect(void * jarg1, void * jarg2) {
97320   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97321   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
97322
97323   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97324   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
97325   {
97326     try {
97327       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Connect(arg1,arg2);
97328     } catch (std::out_of_range& e) {
97329       {
97330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97331       };
97332     } catch (std::exception& e) {
97333       {
97334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97335       };
97336     } catch (Dali::DaliException e) {
97337       {
97338         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97339       };
97340     } catch (...) {
97341       {
97342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97343       };
97344     }
97345   }
97346
97347 }
97348
97349
97350 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
97351   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97352   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
97353
97354   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97355   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
97356   {
97357     try {
97358       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Disconnect(arg1,arg2);
97359     } catch (std::out_of_range& e) {
97360       {
97361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97362       };
97363     } catch (std::exception& e) {
97364       {
97365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97366       };
97367     } catch (Dali::DaliException e) {
97368       {
97369         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97370       };
97371     } catch (...) {
97372       {
97373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97374       };
97375     }
97376   }
97377
97378 }
97379
97380
97381 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3, float jarg4) {
97382   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97383   Dali::Toolkit::ProgressBar arg2 ;
97384   float arg3 ;
97385   float arg4 ;
97386   Dali::Toolkit::ProgressBar *argp2 ;
97387
97388   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97389   argp2 = (Dali::Toolkit::ProgressBar *)jarg2;
97390   if (!argp2) {
97391     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ProgressBar", 0);
97392     return ;
97393   }
97394   arg2 = *argp2;
97395   arg3 = (float)jarg3;
97396   arg4 = (float)jarg4;
97397   {
97398     try {
97399       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Emit(arg1,arg2,arg3,arg4);
97400     } catch (std::out_of_range& e) {
97401       {
97402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97403       };
97404     } catch (std::exception& e) {
97405       {
97406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97407       };
97408     } catch (Dali::DaliException e) {
97409       {
97410         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97411       };
97412     } catch (...) {
97413       {
97414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97415       };
97416     }
97417   }
97418
97419 }
97420
97421
97422 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBarValueChangedSignal() {
97423   void * jresult ;
97424   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *result = 0 ;
97425
97426   {
97427     try {
97428       result = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)new Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) >();
97429     } catch (std::out_of_range& e) {
97430       {
97431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97432       };
97433     } catch (std::exception& e) {
97434       {
97435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97436       };
97437     } catch (Dali::DaliException e) {
97438       {
97439         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97440       };
97441     } catch (...) {
97442       {
97443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97444       };
97445     }
97446   }
97447
97448   jresult = (void *)result;
97449   return jresult;
97450 }
97451
97452
97453 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBarValueChangedSignal(void * jarg1) {
97454   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97455
97456   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97457   {
97458     try {
97459       delete arg1;
97460     } catch (std::out_of_range& e) {
97461       {
97462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97463       };
97464     } catch (std::exception& e) {
97465       {
97466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97467       };
97468     } catch (Dali::DaliException e) {
97469       {
97470         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97471       };
97472     } catch (...) {
97473       {
97474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97475       };
97476     }
97477   }
97478
97479 }
97480
97481
97482 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Empty(void * jarg1) {
97483   unsigned int jresult ;
97484   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
97485   bool result;
97486
97487   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
97488   {
97489     try {
97490       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);
97491     } catch (std::out_of_range& e) {
97492       {
97493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97494       };
97495     } catch (std::exception& e) {
97496       {
97497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97498       };
97499     } catch (Dali::DaliException e) {
97500       {
97501         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97502       };
97503     } catch (...) {
97504       {
97505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97506       };
97507     }
97508   }
97509
97510   jresult = result;
97511   return jresult;
97512 }
97513
97514
97515 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_GetConnectionCount(void * jarg1) {
97516   unsigned long jresult ;
97517   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
97518   std::size_t result;
97519
97520   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
97521   {
97522     try {
97523       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);
97524     } catch (std::out_of_range& e) {
97525       {
97526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97527       };
97528     } catch (std::exception& e) {
97529       {
97530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97531       };
97532     } catch (Dali::DaliException e) {
97533       {
97534         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97535       };
97536     } catch (...) {
97537       {
97538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97539       };
97540     }
97541   }
97542
97543   jresult = (unsigned long)result;
97544   return jresult;
97545 }
97546
97547
97548 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Connect(void * jarg1, void * jarg2) {
97549   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
97550   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
97551
97552   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
97553   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
97554   {
97555     try {
97556       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
97557     } catch (std::out_of_range& e) {
97558       {
97559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97560       };
97561     } catch (std::exception& e) {
97562       {
97563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97564       };
97565     } catch (Dali::DaliException e) {
97566       {
97567         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97568       };
97569     } catch (...) {
97570       {
97571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97572       };
97573     }
97574   }
97575
97576 }
97577
97578
97579 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Disconnect(void * jarg1, void * jarg2) {
97580   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
97581   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
97582
97583   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
97584   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
97585   {
97586     try {
97587       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
97588     } catch (std::out_of_range& e) {
97589       {
97590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97591       };
97592     } catch (std::exception& e) {
97593       {
97594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97595       };
97596     } catch (Dali::DaliException e) {
97597       {
97598         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97599       };
97600     } catch (...) {
97601       {
97602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97603       };
97604     }
97605   }
97606
97607 }
97608
97609
97610 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Emit(void * jarg1, void * jarg2) {
97611   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
97612   Dali::Toolkit::ScrollView::SnapEvent *arg2 = 0 ;
97613
97614   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
97615   arg2 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg2;
97616   if (!arg2) {
97617     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView::SnapEvent const & type is null", 0);
97618     return ;
97619   }
97620   {
97621     try {
97622       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Toolkit::ScrollView::SnapEvent const &)*arg2);
97623     } catch (std::out_of_range& e) {
97624       {
97625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97626       };
97627     } catch (std::exception& e) {
97628       {
97629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97630       };
97631     } catch (Dali::DaliException e) {
97632       {
97633         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97634       };
97635     } catch (...) {
97636       {
97637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97638       };
97639     }
97640   }
97641
97642 }
97643
97644
97645 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewSnapStartedSignal() {
97646   void * jresult ;
97647   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *result = 0 ;
97648
97649   {
97650     try {
97651       result = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)new Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) >();
97652     } catch (std::out_of_range& e) {
97653       {
97654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97655       };
97656     } catch (std::exception& e) {
97657       {
97658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97659       };
97660     } catch (Dali::DaliException e) {
97661       {
97662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97663       };
97664     } catch (...) {
97665       {
97666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97667       };
97668     }
97669   }
97670
97671   jresult = (void *)result;
97672   return jresult;
97673 }
97674
97675
97676 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewSnapStartedSignal(void * jarg1) {
97677   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
97678
97679   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
97680   {
97681     try {
97682       delete arg1;
97683     } catch (std::out_of_range& e) {
97684       {
97685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97686       };
97687     } catch (std::exception& e) {
97688       {
97689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97690       };
97691     } catch (Dali::DaliException e) {
97692       {
97693         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97694       };
97695     } catch (...) {
97696       {
97697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97698       };
97699     }
97700   }
97701
97702 }
97703
97704
97705 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollableSignal_Empty(void * jarg1) {
97706   unsigned int jresult ;
97707   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
97708   bool result;
97709
97710   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
97711   {
97712     try {
97713       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
97714     } catch (std::out_of_range& e) {
97715       {
97716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97717       };
97718     } catch (std::exception& e) {
97719       {
97720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97721       };
97722     } catch (Dali::DaliException e) {
97723       {
97724         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97725       };
97726     } catch (...) {
97727       {
97728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97729       };
97730     }
97731   }
97732
97733   jresult = result;
97734   return jresult;
97735 }
97736
97737
97738 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollableSignal_GetConnectionCount(void * jarg1) {
97739   unsigned long jresult ;
97740   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
97741   std::size_t result;
97742
97743   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
97744   {
97745     try {
97746       result = Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
97747     } catch (std::out_of_range& e) {
97748       {
97749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97750       };
97751     } catch (std::exception& e) {
97752       {
97753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97754       };
97755     } catch (Dali::DaliException e) {
97756       {
97757         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97758       };
97759     } catch (...) {
97760       {
97761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97762       };
97763     }
97764   }
97765
97766   jresult = (unsigned long)result;
97767   return jresult;
97768 }
97769
97770
97771 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Connect(void * jarg1, void * jarg2) {
97772   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
97773   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
97774
97775   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
97776   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
97777   {
97778     try {
97779       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Connect(arg1,arg2);
97780     } catch (std::out_of_range& e) {
97781       {
97782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97783       };
97784     } catch (std::exception& e) {
97785       {
97786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97787       };
97788     } catch (Dali::DaliException e) {
97789       {
97790         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97791       };
97792     } catch (...) {
97793       {
97794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97795       };
97796     }
97797   }
97798
97799 }
97800
97801
97802 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Disconnect(void * jarg1, void * jarg2) {
97803   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
97804   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
97805
97806   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
97807   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
97808   {
97809     try {
97810       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
97811     } catch (std::out_of_range& e) {
97812       {
97813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97814       };
97815     } catch (std::exception& e) {
97816       {
97817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97818       };
97819     } catch (Dali::DaliException e) {
97820       {
97821         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97822       };
97823     } catch (...) {
97824       {
97825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97826       };
97827     }
97828   }
97829
97830 }
97831
97832
97833 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Emit(void * jarg1, void * jarg2) {
97834   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
97835   Dali::Vector2 *arg2 = 0 ;
97836
97837   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
97838   arg2 = (Dali::Vector2 *)jarg2;
97839   if (!arg2) {
97840     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
97841     return ;
97842   }
97843   {
97844     try {
97845       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Vector2 const &)*arg2);
97846     } catch (std::out_of_range& e) {
97847       {
97848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97849       };
97850     } catch (std::exception& e) {
97851       {
97852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97853       };
97854     } catch (Dali::DaliException e) {
97855       {
97856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97857       };
97858     } catch (...) {
97859       {
97860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97861       };
97862     }
97863   }
97864
97865 }
97866
97867
97868 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollableSignal() {
97869   void * jresult ;
97870   Dali::Signal< void (Dali::Vector2 const &) > *result = 0 ;
97871
97872   {
97873     try {
97874       result = (Dali::Signal< void (Dali::Vector2 const &) > *)new Dali::Signal< void (Dali::Vector2 const &) >();
97875     } catch (std::out_of_range& e) {
97876       {
97877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97878       };
97879     } catch (std::exception& e) {
97880       {
97881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97882       };
97883     } catch (Dali::DaliException e) {
97884       {
97885         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97886       };
97887     } catch (...) {
97888       {
97889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97890       };
97891     }
97892   }
97893
97894   jresult = (void *)result;
97895   return jresult;
97896 }
97897
97898
97899 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollableSignal(void * jarg1) {
97900   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
97901
97902   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
97903   {
97904     try {
97905       delete arg1;
97906     } catch (std::out_of_range& e) {
97907       {
97908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97909       };
97910     } catch (std::exception& e) {
97911       {
97912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97913       };
97914     } catch (Dali::DaliException e) {
97915       {
97916         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97917       };
97918     } catch (...) {
97919       {
97920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97921       };
97922     }
97923   }
97924
97925 }
97926
97927
97928
97929 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Empty(void * jarg1) {
97930   unsigned int jresult ;
97931   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
97932   bool result;
97933
97934   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
97935   {
97936     try {
97937       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);
97938     } catch (std::out_of_range& e) {
97939       {
97940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97941       };
97942     } catch (std::exception& e) {
97943       {
97944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97945       };
97946     } catch (Dali::DaliException e) {
97947       {
97948         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97949       };
97950     } catch (...) {
97951       {
97952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97953       };
97954     }
97955   }
97956
97957   jresult = result;
97958   return jresult;
97959 }
97960
97961
97962 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ControlKeySignal_GetConnectionCount(void * jarg1) {
97963   unsigned long jresult ;
97964   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
97965   std::size_t result;
97966
97967   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
97968   {
97969     try {
97970       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);
97971     } catch (std::out_of_range& e) {
97972       {
97973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97974       };
97975     } catch (std::exception& e) {
97976       {
97977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97978       };
97979     } catch (Dali::DaliException e) {
97980       {
97981         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97982       };
97983     } catch (...) {
97984       {
97985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97986       };
97987     }
97988   }
97989
97990   jresult = (unsigned long)result;
97991   return jresult;
97992 }
97993
97994
97995 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Connect(void * jarg1, void * jarg2) {
97996   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
97997   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
97998
97999   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
98000   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
98001   {
98002     try {
98003       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
98004     } catch (std::out_of_range& e) {
98005       {
98006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98007       };
98008     } catch (std::exception& e) {
98009       {
98010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98011       };
98012     } catch (Dali::DaliException e) {
98013       {
98014         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98015       };
98016     } catch (...) {
98017       {
98018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98019       };
98020     }
98021   }
98022
98023 }
98024
98025
98026 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Disconnect(void * jarg1, void * jarg2) {
98027   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
98028   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
98029
98030   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
98031   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
98032   {
98033     try {
98034       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
98035     } catch (std::out_of_range& e) {
98036       {
98037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98038       };
98039     } catch (std::exception& e) {
98040       {
98041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98042       };
98043     } catch (Dali::DaliException e) {
98044       {
98045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98046       };
98047     } catch (...) {
98048       {
98049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98050       };
98051     }
98052   }
98053
98054 }
98055
98056
98057 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
98058   unsigned int jresult ;
98059   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
98060   Dali::Toolkit::Control arg2 ;
98061   Dali::KeyEvent *arg3 = 0 ;
98062   Dali::Toolkit::Control *argp2 ;
98063   bool result;
98064
98065   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
98066   argp2 = (Dali::Toolkit::Control *)jarg2;
98067   if (!argp2) {
98068     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
98069     return 0;
98070   }
98071   arg2 = *argp2;
98072   arg3 = (Dali::KeyEvent *)jarg3;
98073   if (!arg3) {
98074     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
98075     return 0;
98076   }
98077   {
98078     try {
98079       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);
98080     } catch (std::out_of_range& e) {
98081       {
98082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98083       };
98084     } catch (std::exception& e) {
98085       {
98086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98087       };
98088     } catch (Dali::DaliException e) {
98089       {
98090         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98091       };
98092     } catch (...) {
98093       {
98094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98095       };
98096     }
98097   }
98098
98099   jresult = result;
98100   return jresult;
98101 }
98102
98103
98104 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ControlKeySignal() {
98105   void * jresult ;
98106   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *result = 0 ;
98107
98108   {
98109     try {
98110       result = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)new Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) >();
98111     } catch (std::out_of_range& e) {
98112       {
98113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98114       };
98115     } catch (std::exception& e) {
98116       {
98117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98118       };
98119     } catch (Dali::DaliException e) {
98120       {
98121         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98122       };
98123     } catch (...) {
98124       {
98125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98126       };
98127     }
98128   }
98129
98130   jresult = (void *)result;
98131   return jresult;
98132 }
98133
98134
98135 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ControlKeySignal(void * jarg1) {
98136   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
98137
98138   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
98139   {
98140     try {
98141       delete arg1;
98142     } catch (std::out_of_range& e) {
98143       {
98144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98145       };
98146     } catch (std::exception& e) {
98147       {
98148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98149       };
98150     } catch (Dali::DaliException e) {
98151       {
98152         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98153       };
98154     } catch (...) {
98155       {
98156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98157       };
98158     }
98159   }
98160
98161 }
98162
98163
98164 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Empty(void * jarg1) {
98165   unsigned int jresult ;
98166   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98167   bool result;
98168
98169   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98170   {
98171     try {
98172       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
98173     } catch (std::out_of_range& e) {
98174       {
98175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98176       };
98177     } catch (std::exception& e) {
98178       {
98179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98180       };
98181     } catch (Dali::DaliException e) {
98182       {
98183         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98184       };
98185     } catch (...) {
98186       {
98187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98188       };
98189     }
98190   }
98191
98192   jresult = result;
98193   return jresult;
98194 }
98195
98196
98197 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_GetConnectionCount(void * jarg1) {
98198   unsigned long jresult ;
98199   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98200   std::size_t result;
98201
98202   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98203   {
98204     try {
98205       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
98206     } catch (std::out_of_range& e) {
98207       {
98208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98209       };
98210     } catch (std::exception& e) {
98211       {
98212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98213       };
98214     } catch (Dali::DaliException e) {
98215       {
98216         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98217       };
98218     } catch (...) {
98219       {
98220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98221       };
98222     }
98223   }
98224
98225   jresult = (unsigned long)result;
98226   return jresult;
98227 }
98228
98229
98230 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Connect(void * jarg1, void * jarg2) {
98231   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98232   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
98233
98234   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98235   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
98236   {
98237     try {
98238       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
98239     } catch (std::out_of_range& e) {
98240       {
98241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98242       };
98243     } catch (std::exception& e) {
98244       {
98245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98246       };
98247     } catch (Dali::DaliException e) {
98248       {
98249         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98250       };
98251     } catch (...) {
98252       {
98253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98254       };
98255     }
98256   }
98257
98258 }
98259
98260
98261 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Disconnect(void * jarg1, void * jarg2) {
98262   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98263   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
98264
98265   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98266   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
98267   {
98268     try {
98269       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
98270     } catch (std::out_of_range& e) {
98271       {
98272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98273       };
98274     } catch (std::exception& e) {
98275       {
98276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98277       };
98278     } catch (Dali::DaliException e) {
98279       {
98280         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98281       };
98282     } catch (...) {
98283       {
98284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98285       };
98286     }
98287   }
98288
98289 }
98290
98291
98292 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Emit(void * jarg1, void * jarg2) {
98293   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98294   Dali::Toolkit::Control arg2 ;
98295   Dali::Toolkit::Control *argp2 ;
98296
98297   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98298   argp2 = (Dali::Toolkit::Control *)jarg2;
98299   if (!argp2) {
98300     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
98301     return ;
98302   }
98303   arg2 = *argp2;
98304   {
98305     try {
98306       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
98307     } catch (std::out_of_range& e) {
98308       {
98309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98310       };
98311     } catch (std::exception& e) {
98312       {
98313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98314       };
98315     } catch (Dali::DaliException e) {
98316       {
98317         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98318       };
98319     } catch (...) {
98320       {
98321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98322       };
98323     }
98324   }
98325
98326 }
98327
98328
98329 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusSignal() {
98330   void * jresult ;
98331   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
98332
98333   {
98334     try {
98335       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
98336     } catch (std::out_of_range& e) {
98337       {
98338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98339       };
98340     } catch (std::exception& e) {
98341       {
98342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98343       };
98344     } catch (Dali::DaliException e) {
98345       {
98346         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98347       };
98348     } catch (...) {
98349       {
98350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98351       };
98352     }
98353   }
98354
98355   jresult = (void *)result;
98356   return jresult;
98357 }
98358
98359
98360 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusSignal(void * jarg1) {
98361   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98362
98363   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98364   {
98365     try {
98366       delete arg1;
98367     } catch (std::out_of_range& e) {
98368       {
98369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98370       };
98371     } catch (std::exception& e) {
98372       {
98373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98374       };
98375     } catch (Dali::DaliException e) {
98376       {
98377         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98378       };
98379     } catch (...) {
98380       {
98381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98382       };
98383     }
98384   }
98385
98386 }
98387
98388
98389 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VideoViewSignal_Empty(void * jarg1) {
98390   unsigned int jresult ;
98391   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
98392   bool result;
98393
98394   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
98395   {
98396     try {
98397       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
98398     } catch (std::out_of_range& e) {
98399       {
98400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98401       };
98402     } catch (std::exception& e) {
98403       {
98404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98405       };
98406     } catch (Dali::DaliException e) {
98407       {
98408         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98409       };
98410     } catch (...) {
98411       {
98412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98413       };
98414     }
98415   }
98416
98417   jresult = result;
98418   return jresult;
98419 }
98420
98421
98422 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VideoViewSignal_GetConnectionCount(void * jarg1) {
98423   unsigned long jresult ;
98424   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
98425   std::size_t result;
98426
98427   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
98428   {
98429     try {
98430       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
98431     } catch (std::out_of_range& e) {
98432       {
98433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98434       };
98435     } catch (std::exception& e) {
98436       {
98437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98438       };
98439     } catch (Dali::DaliException e) {
98440       {
98441         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98442       };
98443     } catch (...) {
98444       {
98445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98446       };
98447     }
98448   }
98449
98450   jresult = (unsigned long)result;
98451   return jresult;
98452 }
98453
98454
98455 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Connect(void * jarg1, void * jarg2) {
98456   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
98457   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
98458
98459   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
98460   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
98461   {
98462     try {
98463       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Connect(arg1,arg2);
98464     } catch (std::out_of_range& e) {
98465       {
98466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98467       };
98468     } catch (std::exception& e) {
98469       {
98470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98471       };
98472     } catch (Dali::DaliException e) {
98473       {
98474         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98475       };
98476     } catch (...) {
98477       {
98478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98479       };
98480     }
98481   }
98482
98483 }
98484
98485
98486 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Disconnect(void * jarg1, void * jarg2) {
98487   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
98488   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
98489
98490   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
98491   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
98492   {
98493     try {
98494       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Disconnect(arg1,arg2);
98495     } catch (std::out_of_range& e) {
98496       {
98497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98498       };
98499     } catch (std::exception& e) {
98500       {
98501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98502       };
98503     } catch (Dali::DaliException e) {
98504       {
98505         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98506       };
98507     } catch (...) {
98508       {
98509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98510       };
98511     }
98512   }
98513
98514 }
98515
98516
98517 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Emit(void * jarg1, void * jarg2) {
98518   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
98519   Dali::Toolkit::VideoView *arg2 = 0 ;
98520
98521   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
98522   arg2 = (Dali::Toolkit::VideoView *)jarg2;
98523   if (!arg2) {
98524     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView & type is null", 0);
98525     return ;
98526   }
98527   {
98528     try {
98529       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Emit(arg1,*arg2);
98530     } catch (std::out_of_range& e) {
98531       {
98532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98533       };
98534     } catch (std::exception& e) {
98535       {
98536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98537       };
98538     } catch (Dali::DaliException e) {
98539       {
98540         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98541       };
98542     } catch (...) {
98543       {
98544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98545       };
98546     }
98547   }
98548
98549 }
98550
98551
98552 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoViewSignal() {
98553   void * jresult ;
98554   Dali::Signal< void (Dali::Toolkit::VideoView &) > *result = 0 ;
98555
98556   {
98557     try {
98558       result = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)new Dali::Signal< void (Dali::Toolkit::VideoView &) >();
98559     } catch (std::out_of_range& e) {
98560       {
98561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98562       };
98563     } catch (std::exception& e) {
98564       {
98565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98566       };
98567     } catch (Dali::DaliException e) {
98568       {
98569         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98570       };
98571     } catch (...) {
98572       {
98573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98574       };
98575     }
98576   }
98577
98578   jresult = (void *)result;
98579   return jresult;
98580 }
98581
98582
98583 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoViewSignal(void * jarg1) {
98584   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
98585
98586   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
98587   {
98588     try {
98589       delete arg1;
98590     } catch (std::out_of_range& e) {
98591       {
98592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98593       };
98594     } catch (std::exception& e) {
98595       {
98596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98597       };
98598     } catch (Dali::DaliException e) {
98599       {
98600         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98601       };
98602     } catch (...) {
98603       {
98604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98605       };
98606     }
98607   }
98608
98609 }
98610
98611
98612 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Empty(void * jarg1) {
98613   unsigned int jresult ;
98614   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
98615   bool result;
98616
98617   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
98618   {
98619     try {
98620       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
98621     } catch (std::out_of_range& e) {
98622       {
98623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98624       };
98625     } catch (std::exception& e) {
98626       {
98627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98628       };
98629     } catch (Dali::DaliException e) {
98630       {
98631         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98632       };
98633     } catch (...) {
98634       {
98635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98636       };
98637     }
98638   }
98639
98640   jresult = result;
98641   return jresult;
98642 }
98643
98644
98645 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_GetConnectionCount(void * jarg1) {
98646   unsigned long jresult ;
98647   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
98648   std::size_t result;
98649
98650   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
98651   {
98652     try {
98653       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
98654     } catch (std::out_of_range& e) {
98655       {
98656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98657       };
98658     } catch (std::exception& e) {
98659       {
98660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98661       };
98662     } catch (Dali::DaliException e) {
98663       {
98664         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98665       };
98666     } catch (...) {
98667       {
98668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98669       };
98670     }
98671   }
98672
98673   jresult = (unsigned long)result;
98674   return jresult;
98675 }
98676
98677
98678 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Connect(void * jarg1, void * jarg2) {
98679   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
98680   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
98681
98682   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
98683   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
98684   {
98685     try {
98686       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Connect(arg1,arg2);
98687     } catch (std::out_of_range& e) {
98688       {
98689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98690       };
98691     } catch (std::exception& e) {
98692       {
98693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98694       };
98695     } catch (Dali::DaliException e) {
98696       {
98697         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98698       };
98699     } catch (...) {
98700       {
98701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98702       };
98703     }
98704   }
98705
98706 }
98707
98708
98709 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
98710   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
98711   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
98712
98713   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
98714   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
98715   {
98716     try {
98717       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Disconnect(arg1,arg2);
98718     } catch (std::out_of_range& e) {
98719       {
98720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98721       };
98722     } catch (std::exception& e) {
98723       {
98724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98725       };
98726     } catch (Dali::DaliException e) {
98727       {
98728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98729       };
98730     } catch (...) {
98731       {
98732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98733       };
98734     }
98735   }
98736
98737 }
98738
98739
98740 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3) {
98741   unsigned int jresult ;
98742   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
98743   Dali::Toolkit::Slider arg2 ;
98744   float arg3 ;
98745   Dali::Toolkit::Slider *argp2 ;
98746   bool result;
98747
98748   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
98749   argp2 = (Dali::Toolkit::Slider *)jarg2;
98750   if (!argp2) {
98751     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
98752     return 0;
98753   }
98754   arg2 = *argp2;
98755   arg3 = (float)jarg3;
98756   {
98757     try {
98758       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Emit(arg1,arg2,arg3);
98759     } catch (std::out_of_range& e) {
98760       {
98761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98762       };
98763     } catch (std::exception& e) {
98764       {
98765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98766       };
98767     } catch (Dali::DaliException e) {
98768       {
98769         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98770       };
98771     } catch (...) {
98772       {
98773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98774       };
98775     }
98776   }
98777
98778   jresult = result;
98779   return jresult;
98780 }
98781
98782
98783 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderValueChangedSignal() {
98784   void * jresult ;
98785   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *result = 0 ;
98786
98787   {
98788     try {
98789       result = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,float) >();
98790     } catch (std::out_of_range& e) {
98791       {
98792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98793       };
98794     } catch (std::exception& e) {
98795       {
98796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98797       };
98798     } catch (Dali::DaliException e) {
98799       {
98800         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98801       };
98802     } catch (...) {
98803       {
98804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98805       };
98806     }
98807   }
98808
98809   jresult = (void *)result;
98810   return jresult;
98811 }
98812
98813
98814 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderValueChangedSignal(void * jarg1) {
98815   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
98816
98817   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
98818   {
98819     try {
98820       delete arg1;
98821     } catch (std::out_of_range& e) {
98822       {
98823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98824       };
98825     } catch (std::exception& e) {
98826       {
98827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98828       };
98829     } catch (Dali::DaliException e) {
98830       {
98831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98832       };
98833     } catch (...) {
98834       {
98835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98836       };
98837     }
98838   }
98839
98840 }
98841
98842
98843 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Empty(void * jarg1) {
98844   unsigned int jresult ;
98845   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
98846   bool result;
98847
98848   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
98849   {
98850     try {
98851       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
98852     } catch (std::out_of_range& e) {
98853       {
98854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98855       };
98856     } catch (std::exception& e) {
98857       {
98858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98859       };
98860     } catch (Dali::DaliException e) {
98861       {
98862         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98863       };
98864     } catch (...) {
98865       {
98866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98867       };
98868     }
98869   }
98870
98871   jresult = result;
98872   return jresult;
98873 }
98874
98875
98876 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_GetConnectionCount(void * jarg1) {
98877   unsigned long jresult ;
98878   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
98879   std::size_t result;
98880
98881   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
98882   {
98883     try {
98884       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
98885     } catch (std::out_of_range& e) {
98886       {
98887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98888       };
98889     } catch (std::exception& e) {
98890       {
98891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98892       };
98893     } catch (Dali::DaliException e) {
98894       {
98895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98896       };
98897     } catch (...) {
98898       {
98899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98900       };
98901     }
98902   }
98903
98904   jresult = (unsigned long)result;
98905   return jresult;
98906 }
98907
98908
98909 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Connect(void * jarg1, void * jarg2) {
98910   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
98911   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
98912
98913   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
98914   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
98915   {
98916     try {
98917       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Connect(arg1,arg2);
98918     } catch (std::out_of_range& e) {
98919       {
98920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98921       };
98922     } catch (std::exception& e) {
98923       {
98924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98925       };
98926     } catch (Dali::DaliException e) {
98927       {
98928         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98929       };
98930     } catch (...) {
98931       {
98932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98933       };
98934     }
98935   }
98936
98937 }
98938
98939
98940 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Disconnect(void * jarg1, void * jarg2) {
98941   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
98942   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
98943
98944   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
98945   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
98946   {
98947     try {
98948       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Disconnect(arg1,arg2);
98949     } catch (std::out_of_range& e) {
98950       {
98951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98952       };
98953     } catch (std::exception& e) {
98954       {
98955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98956       };
98957     } catch (Dali::DaliException e) {
98958       {
98959         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98960       };
98961     } catch (...) {
98962       {
98963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98964       };
98965     }
98966   }
98967
98968 }
98969
98970
98971 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
98972   unsigned int jresult ;
98973   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
98974   Dali::Toolkit::Slider arg2 ;
98975   int arg3 ;
98976   Dali::Toolkit::Slider *argp2 ;
98977   bool result;
98978
98979   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
98980   argp2 = (Dali::Toolkit::Slider *)jarg2;
98981   if (!argp2) {
98982     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
98983     return 0;
98984   }
98985   arg2 = *argp2;
98986   arg3 = (int)jarg3;
98987   {
98988     try {
98989       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Emit(arg1,arg2,arg3);
98990     } catch (std::out_of_range& e) {
98991       {
98992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98993       };
98994     } catch (std::exception& e) {
98995       {
98996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98997       };
98998     } catch (Dali::DaliException e) {
98999       {
99000         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99001       };
99002     } catch (...) {
99003       {
99004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99005       };
99006     }
99007   }
99008
99009   jresult = result;
99010   return jresult;
99011 }
99012
99013
99014 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderMarkReachedSignal() {
99015   void * jresult ;
99016   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *result = 0 ;
99017
99018   {
99019     try {
99020       result = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,int) >();
99021     } catch (std::out_of_range& e) {
99022       {
99023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99024       };
99025     } catch (std::exception& e) {
99026       {
99027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99028       };
99029     } catch (Dali::DaliException e) {
99030       {
99031         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99032       };
99033     } catch (...) {
99034       {
99035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99036       };
99037     }
99038   }
99039
99040   jresult = (void *)result;
99041   return jresult;
99042 }
99043
99044
99045 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderMarkReachedSignal(void * jarg1) {
99046   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
99047
99048   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
99049   {
99050     try {
99051       delete arg1;
99052     } catch (std::out_of_range& e) {
99053       {
99054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99055       };
99056     } catch (std::exception& e) {
99057       {
99058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99059       };
99060     } catch (Dali::DaliException e) {
99061       {
99062         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99063       };
99064     } catch (...) {
99065       {
99066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99067       };
99068     }
99069   }
99070
99071 }
99072
99073
99074 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_0() {
99075   void * jresult ;
99076   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
99077
99078   {
99079     try {
99080       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >();
99081     } catch (std::out_of_range& e) {
99082       {
99083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99084       };
99085     } catch (std::exception& e) {
99086       {
99087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99088       };
99089     } catch (Dali::DaliException e) {
99090       {
99091         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99092       };
99093     } catch (...) {
99094       {
99095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99096       };
99097     }
99098   }
99099
99100   jresult = (void *)result;
99101   return jresult;
99102 }
99103
99104
99105 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_1(void * jarg1) {
99106   void * jresult ;
99107   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
99108   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
99109
99110   arg1 = (Dali::Toolkit::Ruler *)jarg1;
99111   {
99112     try {
99113       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >(arg1);
99114     } catch (std::out_of_range& e) {
99115       {
99116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99117       };
99118     } catch (std::exception& e) {
99119       {
99120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99121       };
99122     } catch (Dali::DaliException e) {
99123       {
99124         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99125       };
99126     } catch (...) {
99127       {
99128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99129       };
99130     }
99131   }
99132
99133   jresult = (void *)result;
99134   return jresult;
99135 }
99136
99137
99138 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_2(void * jarg1) {
99139   void * jresult ;
99140   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = 0 ;
99141   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
99142
99143   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99144   if (!arg1) {
99145     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
99146     return 0;
99147   }
99148   {
99149     try {
99150       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg1);
99151     } catch (std::out_of_range& e) {
99152       {
99153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99154       };
99155     } catch (std::exception& e) {
99156       {
99157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99158       };
99159     } catch (Dali::DaliException e) {
99160       {
99161         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99162       };
99163     } catch (...) {
99164       {
99165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99166       };
99167     }
99168   }
99169
99170   jresult = (void *)result;
99171   return jresult;
99172 }
99173
99174
99175 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerPtr(void * jarg1) {
99176   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99177
99178   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99179   {
99180     try {
99181       delete arg1;
99182     } catch (std::out_of_range& e) {
99183       {
99184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99185       };
99186     } catch (std::exception& e) {
99187       {
99188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99189       };
99190     } catch (Dali::DaliException e) {
99191       {
99192         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99193       };
99194     } catch (...) {
99195       {
99196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99197       };
99198     }
99199   }
99200
99201 }
99202
99203
99204 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Get(void * jarg1) {
99205   void * jresult ;
99206   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99207   Dali::Toolkit::Ruler *result = 0 ;
99208
99209   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99210   {
99211     try {
99212       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->Get();
99213     } catch (std::out_of_range& e) {
99214       {
99215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99216       };
99217     } catch (std::exception& e) {
99218       {
99219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99220       };
99221     } catch (Dali::DaliException e) {
99222       {
99223         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99224       };
99225     } catch (...) {
99226       {
99227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99228       };
99229     }
99230   }
99231
99232   jresult = (void *)result;
99233   return jresult;
99234 }
99235
99236
99237 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___deref__(void * jarg1) {
99238   void * jresult ;
99239   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99240   Dali::Toolkit::Ruler *result = 0 ;
99241
99242   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99243   {
99244     try {
99245       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator ->();
99246     } catch (std::out_of_range& e) {
99247       {
99248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99249       };
99250     } catch (std::exception& e) {
99251       {
99252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99253       };
99254     } catch (Dali::DaliException e) {
99255       {
99256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99257       };
99258     } catch (...) {
99259       {
99260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99261       };
99262     }
99263   }
99264
99265   jresult = (void *)result;
99266   return jresult;
99267 }
99268
99269
99270 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___ref__(void * jarg1) {
99271   void * jresult ;
99272   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99273   Dali::Toolkit::Ruler *result = 0 ;
99274
99275   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99276   {
99277     try {
99278       result = (Dali::Toolkit::Ruler *) &((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator *();
99279     } catch (std::out_of_range& e) {
99280       {
99281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99282       };
99283     } catch (std::exception& e) {
99284       {
99285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99286       };
99287     } catch (Dali::DaliException e) {
99288       {
99289         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99290       };
99291     } catch (...) {
99292       {
99293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99294       };
99295     }
99296   }
99297
99298   jresult = (void *)result;
99299   return jresult;
99300 }
99301
99302
99303 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_0(void * jarg1, void * jarg2) {
99304   void * jresult ;
99305   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99306   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg2 = 0 ;
99307   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
99308
99309   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99310   arg2 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg2;
99311   if (!arg2) {
99312     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
99313     return 0;
99314   }
99315   {
99316     try {
99317       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg2);
99318     } catch (std::out_of_range& e) {
99319       {
99320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99321       };
99322     } catch (std::exception& e) {
99323       {
99324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99325       };
99326     } catch (Dali::DaliException e) {
99327       {
99328         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99329       };
99330     } catch (...) {
99331       {
99332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99333       };
99334     }
99335   }
99336
99337   jresult = (void *)result;
99338   return jresult;
99339 }
99340
99341
99342 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_1(void * jarg1, void * jarg2) {
99343   void * jresult ;
99344   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99345   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
99346   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
99347
99348   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99349   arg2 = (Dali::Toolkit::Ruler *)jarg2;
99350   {
99351     try {
99352       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =(arg2);
99353     } catch (std::out_of_range& e) {
99354       {
99355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99356       };
99357     } catch (std::exception& e) {
99358       {
99359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99360       };
99361     } catch (Dali::DaliException e) {
99362       {
99363         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99364       };
99365     } catch (...) {
99366       {
99367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99368       };
99369     }
99370   }
99371
99372   jresult = (void *)result;
99373   return jresult;
99374 }
99375
99376
99377 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_0(void * jarg1) {
99378   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99379
99380   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99381   {
99382     try {
99383       (arg1)->Reset();
99384     } catch (std::out_of_range& e) {
99385       {
99386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99387       };
99388     } catch (std::exception& e) {
99389       {
99390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99391       };
99392     } catch (Dali::DaliException e) {
99393       {
99394         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99395       };
99396     } catch (...) {
99397       {
99398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99399       };
99400     }
99401   }
99402
99403 }
99404
99405
99406 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_1(void * jarg1, void * jarg2) {
99407   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99408   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
99409
99410   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99411   arg2 = (Dali::Toolkit::Ruler *)jarg2;
99412   {
99413     try {
99414       (arg1)->Reset(arg2);
99415     } catch (std::out_of_range& e) {
99416       {
99417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99418       };
99419     } catch (std::exception& e) {
99420       {
99421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99422       };
99423     } catch (Dali::DaliException e) {
99424       {
99425         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99426       };
99427     } catch (...) {
99428       {
99429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99430       };
99431     }
99432   }
99433
99434 }
99435
99436
99437 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Detach(void * jarg1) {
99438   void * jresult ;
99439   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99440   Dali::Toolkit::Ruler *result = 0 ;
99441
99442   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99443   {
99444     try {
99445       result = (Dali::Toolkit::Ruler *)(arg1)->Detach();
99446     } catch (std::out_of_range& e) {
99447       {
99448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99449       };
99450     } catch (std::exception& e) {
99451       {
99452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99453       };
99454     } catch (Dali::DaliException e) {
99455       {
99456         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99457       };
99458     } catch (...) {
99459       {
99460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99461       };
99462     }
99463   }
99464
99465   jresult = (void *)result;
99466   return jresult;
99467 }
99468
99469
99470 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
99471   float jresult ;
99472   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99473   float arg2 ;
99474   float arg3 ;
99475   float result;
99476
99477   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99478   arg2 = (float)jarg2;
99479   arg3 = (float)jarg3;
99480   {
99481     try {
99482       result = (float)(*arg1)->Snap(arg2,arg3);
99483     } catch (std::out_of_range& e) {
99484       {
99485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99486       };
99487     } catch (std::exception& e) {
99488       {
99489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99490       };
99491     } catch (Dali::DaliException e) {
99492       {
99493         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99494       };
99495     } catch (...) {
99496       {
99497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99498       };
99499     }
99500   }
99501
99502   jresult = result;
99503   return jresult;
99504 }
99505
99506
99507 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_1(void * jarg1, float jarg2) {
99508   float jresult ;
99509   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99510   float arg2 ;
99511   float result;
99512
99513   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99514   arg2 = (float)jarg2;
99515   {
99516     try {
99517       result = (float)(*arg1)->Snap(arg2);
99518     } catch (std::out_of_range& e) {
99519       {
99520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99521       };
99522     } catch (std::exception& e) {
99523       {
99524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99525       };
99526     } catch (Dali::DaliException e) {
99527       {
99528         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99529       };
99530     } catch (...) {
99531       {
99532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99533       };
99534     }
99535   }
99536
99537   jresult = result;
99538   return jresult;
99539 }
99540
99541
99542 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
99543   float jresult ;
99544   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99545   unsigned int arg2 ;
99546   unsigned int *arg3 = 0 ;
99547   bool arg4 ;
99548   float result;
99549
99550   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99551   arg2 = (unsigned int)jarg2;
99552   arg3 = (unsigned int *)jarg3;
99553   arg4 = jarg4 ? true : false;
99554   {
99555     try {
99556       result = (float)(*arg1)->GetPositionFromPage(arg2,*arg3,arg4);
99557     } catch (std::out_of_range& e) {
99558       {
99559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99560       };
99561     } catch (std::exception& e) {
99562       {
99563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99564       };
99565     } catch (Dali::DaliException e) {
99566       {
99567         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99568       };
99569     } catch (...) {
99570       {
99571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99572       };
99573     }
99574   }
99575
99576   jresult = result;
99577   return jresult;
99578 }
99579
99580
99581 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
99582   unsigned int jresult ;
99583   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99584   float arg2 ;
99585   bool arg3 ;
99586   unsigned int result;
99587
99588   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99589   arg2 = (float)jarg2;
99590   arg3 = jarg3 ? true : false;
99591   {
99592     try {
99593       result = (unsigned int)(*arg1)->GetPageFromPosition(arg2,arg3);
99594     } catch (std::out_of_range& e) {
99595       {
99596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99597       };
99598     } catch (std::exception& e) {
99599       {
99600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99601       };
99602     } catch (Dali::DaliException e) {
99603       {
99604         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99605       };
99606     } catch (...) {
99607       {
99608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99609       };
99610     }
99611   }
99612
99613   jresult = result;
99614   return jresult;
99615 }
99616
99617
99618 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetTotalPages(void * jarg1) {
99619   unsigned int jresult ;
99620   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99621   unsigned int result;
99622
99623   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99624   {
99625     try {
99626       result = (unsigned int)(*arg1)->GetTotalPages();
99627     } catch (std::out_of_range& e) {
99628       {
99629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99630       };
99631     } catch (std::exception& e) {
99632       {
99633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99634       };
99635     } catch (Dali::DaliException e) {
99636       {
99637         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99638       };
99639     } catch (...) {
99640       {
99641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99642       };
99643     }
99644   }
99645
99646   jresult = result;
99647   return jresult;
99648 }
99649
99650
99651 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_GetType(void * jarg1) {
99652   int jresult ;
99653   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99654   Dali::Toolkit::Ruler::RulerType result;
99655
99656   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99657   {
99658     try {
99659       result = (Dali::Toolkit::Ruler::RulerType)(*arg1)->GetType();
99660     } catch (std::out_of_range& e) {
99661       {
99662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99663       };
99664     } catch (std::exception& e) {
99665       {
99666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99667       };
99668     } catch (Dali::DaliException e) {
99669       {
99670         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99671       };
99672     } catch (...) {
99673       {
99674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99675       };
99676     }
99677   }
99678
99679   jresult = (int)result;
99680   return jresult;
99681 }
99682
99683
99684 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_IsEnabled(void * jarg1) {
99685   unsigned int jresult ;
99686   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99687   bool result;
99688
99689   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99690   {
99691     try {
99692       result = (bool)(*arg1)->IsEnabled();
99693     } catch (std::out_of_range& e) {
99694       {
99695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99696       };
99697     } catch (std::exception& e) {
99698       {
99699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99700       };
99701     } catch (Dali::DaliException e) {
99702       {
99703         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99704       };
99705     } catch (...) {
99706       {
99707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99708       };
99709     }
99710   }
99711
99712   jresult = result;
99713   return jresult;
99714 }
99715
99716
99717 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Enable(void * jarg1) {
99718   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99719
99720   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99721   {
99722     try {
99723       (*arg1)->Enable();
99724     } catch (std::out_of_range& e) {
99725       {
99726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99727       };
99728     } catch (std::exception& e) {
99729       {
99730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99731       };
99732     } catch (Dali::DaliException e) {
99733       {
99734         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99735       };
99736     } catch (...) {
99737       {
99738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99739       };
99740     }
99741   }
99742
99743 }
99744
99745
99746 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Disable(void * jarg1) {
99747   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99748
99749   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99750   {
99751     try {
99752       (*arg1)->Disable();
99753     } catch (std::out_of_range& e) {
99754       {
99755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99756       };
99757     } catch (std::exception& e) {
99758       {
99759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99760       };
99761     } catch (Dali::DaliException e) {
99762       {
99763         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99764       };
99765     } catch (...) {
99766       {
99767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99768       };
99769     }
99770   }
99771
99772 }
99773
99774
99775 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_SetDomain(void * jarg1, void * jarg2) {
99776   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99777   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
99778   Dali::Toolkit::RulerDomain *argp2 ;
99779
99780   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99781   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
99782   if (!argp2) {
99783     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
99784     return ;
99785   }
99786   arg2 = *argp2;
99787   {
99788     try {
99789       (*arg1)->SetDomain(arg2);
99790     } catch (std::out_of_range& e) {
99791       {
99792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99793       };
99794     } catch (std::exception& e) {
99795       {
99796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99797       };
99798     } catch (Dali::DaliException e) {
99799       {
99800         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99801       };
99802     } catch (...) {
99803       {
99804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99805       };
99806     }
99807   }
99808
99809 }
99810
99811
99812 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_GetDomain(void * jarg1) {
99813   void * jresult ;
99814   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99815   Dali::Toolkit::RulerDomain *result = 0 ;
99816
99817   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99818   {
99819     try {
99820       result = (Dali::Toolkit::RulerDomain *) &(*arg1)->GetDomain();
99821     } catch (std::out_of_range& e) {
99822       {
99823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99824       };
99825     } catch (std::exception& e) {
99826       {
99827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99828       };
99829     } catch (Dali::DaliException e) {
99830       {
99831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99832       };
99833     } catch (...) {
99834       {
99835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99836       };
99837     }
99838   }
99839
99840   jresult = (void *)result;
99841   return jresult;
99842 }
99843
99844
99845 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_DisableDomain(void * jarg1) {
99846   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99847
99848   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99849   {
99850     try {
99851       (*arg1)->DisableDomain();
99852     } catch (std::out_of_range& e) {
99853       {
99854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99855       };
99856     } catch (std::exception& e) {
99857       {
99858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99859       };
99860     } catch (Dali::DaliException e) {
99861       {
99862         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99863       };
99864     } catch (...) {
99865       {
99866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99867       };
99868     }
99869   }
99870
99871 }
99872
99873
99874 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
99875   float jresult ;
99876   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99877   float arg2 ;
99878   float arg3 ;
99879   float arg4 ;
99880   float result;
99881
99882   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99883   arg2 = (float)jarg2;
99884   arg3 = (float)jarg3;
99885   arg4 = (float)jarg4;
99886   {
99887     try {
99888       result = (float)(*arg1)->Clamp(arg2,arg3,arg4);
99889     } catch (std::out_of_range& e) {
99890       {
99891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99892       };
99893     } catch (std::exception& e) {
99894       {
99895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99896       };
99897     } catch (Dali::DaliException e) {
99898       {
99899         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99900       };
99901     } catch (...) {
99902       {
99903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99904       };
99905     }
99906   }
99907
99908   jresult = result;
99909   return jresult;
99910 }
99911
99912
99913 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
99914   float jresult ;
99915   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99916   float arg2 ;
99917   float arg3 ;
99918   float result;
99919
99920   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99921   arg2 = (float)jarg2;
99922   arg3 = (float)jarg3;
99923   {
99924     try {
99925       result = (float)(*arg1)->Clamp(arg2,arg3);
99926     } catch (std::out_of_range& e) {
99927       {
99928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99929       };
99930     } catch (std::exception& e) {
99931       {
99932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99933       };
99934     } catch (Dali::DaliException e) {
99935       {
99936         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99937       };
99938     } catch (...) {
99939       {
99940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99941       };
99942     }
99943   }
99944
99945   jresult = result;
99946   return jresult;
99947 }
99948
99949
99950 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_2(void * jarg1, float jarg2) {
99951   float jresult ;
99952   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99953   float arg2 ;
99954   float result;
99955
99956   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99957   arg2 = (float)jarg2;
99958   {
99959     try {
99960       result = (float)(*arg1)->Clamp(arg2);
99961     } catch (std::out_of_range& e) {
99962       {
99963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99964       };
99965     } catch (std::exception& e) {
99966       {
99967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99968       };
99969     } catch (Dali::DaliException e) {
99970       {
99971         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99972       };
99973     } catch (...) {
99974       {
99975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99976       };
99977     }
99978   }
99979
99980   jresult = result;
99981   return jresult;
99982 }
99983
99984
99985 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
99986   float jresult ;
99987   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99988   float arg2 ;
99989   float arg3 ;
99990   float arg4 ;
99991   Dali::Toolkit::ClampState *arg5 = 0 ;
99992   float result;
99993
99994   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99995   arg2 = (float)jarg2;
99996   arg3 = (float)jarg3;
99997   arg4 = (float)jarg4;
99998   arg5 = (Dali::Toolkit::ClampState *)jarg5;
99999   if (!arg5) {
100000     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
100001     return 0;
100002   }
100003   {
100004     try {
100005       result = (float)(*arg1)->Clamp(arg2,arg3,arg4,*arg5);
100006     } catch (std::out_of_range& e) {
100007       {
100008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100009       };
100010     } catch (std::exception& e) {
100011       {
100012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100013       };
100014     } catch (Dali::DaliException e) {
100015       {
100016         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100017       };
100018     } catch (...) {
100019       {
100020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100021       };
100022     }
100023   }
100024
100025   jresult = result;
100026   return jresult;
100027 }
100028
100029
100030 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
100031   float jresult ;
100032   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100033   float arg2 ;
100034   float arg3 ;
100035   float arg4 ;
100036   float arg5 ;
100037   float result;
100038
100039   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100040   arg2 = (float)jarg2;
100041   arg3 = (float)jarg3;
100042   arg4 = (float)jarg4;
100043   arg5 = (float)jarg5;
100044   {
100045     try {
100046       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
100047     } catch (std::out_of_range& e) {
100048       {
100049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100050       };
100051     } catch (std::exception& e) {
100052       {
100053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100054       };
100055     } catch (Dali::DaliException e) {
100056       {
100057         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100058       };
100059     } catch (...) {
100060       {
100061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100062       };
100063     }
100064   }
100065
100066   jresult = result;
100067   return jresult;
100068 }
100069
100070
100071 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
100072   float jresult ;
100073   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100074   float arg2 ;
100075   float arg3 ;
100076   float arg4 ;
100077   float result;
100078
100079   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100080   arg2 = (float)jarg2;
100081   arg3 = (float)jarg3;
100082   arg4 = (float)jarg4;
100083   {
100084     try {
100085       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4);
100086     } catch (std::out_of_range& e) {
100087       {
100088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100089       };
100090     } catch (std::exception& e) {
100091       {
100092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100093       };
100094     } catch (Dali::DaliException e) {
100095       {
100096         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100097       };
100098     } catch (...) {
100099       {
100100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100101       };
100102     }
100103   }
100104
100105   jresult = result;
100106   return jresult;
100107 }
100108
100109
100110 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
100111   float jresult ;
100112   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100113   float arg2 ;
100114   float arg3 ;
100115   float result;
100116
100117   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100118   arg2 = (float)jarg2;
100119   arg3 = (float)jarg3;
100120   {
100121     try {
100122       result = (float)(*arg1)->SnapAndClamp(arg2,arg3);
100123     } catch (std::out_of_range& e) {
100124       {
100125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100126       };
100127     } catch (std::exception& e) {
100128       {
100129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100130       };
100131     } catch (Dali::DaliException e) {
100132       {
100133         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100134       };
100135     } catch (...) {
100136       {
100137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100138       };
100139     }
100140   }
100141
100142   jresult = result;
100143   return jresult;
100144 }
100145
100146
100147 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
100148   float jresult ;
100149   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100150   float arg2 ;
100151   float result;
100152
100153   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100154   arg2 = (float)jarg2;
100155   {
100156     try {
100157       result = (float)(*arg1)->SnapAndClamp(arg2);
100158     } catch (std::out_of_range& e) {
100159       {
100160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100161       };
100162     } catch (std::exception& e) {
100163       {
100164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100165       };
100166     } catch (Dali::DaliException e) {
100167       {
100168         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100169       };
100170     } catch (...) {
100171       {
100172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100173       };
100174     }
100175   }
100176
100177   jresult = result;
100178   return jresult;
100179 }
100180
100181
100182 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
100183   float jresult ;
100184   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100185   float arg2 ;
100186   float arg3 ;
100187   float arg4 ;
100188   float arg5 ;
100189   Dali::Toolkit::ClampState *arg6 = 0 ;
100190   float result;
100191
100192   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100193   arg2 = (float)jarg2;
100194   arg3 = (float)jarg3;
100195   arg4 = (float)jarg4;
100196   arg5 = (float)jarg5;
100197   arg6 = (Dali::Toolkit::ClampState *)jarg6;
100198   if (!arg6) {
100199     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
100200     return 0;
100201   }
100202   {
100203     try {
100204       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
100205     } catch (std::out_of_range& e) {
100206       {
100207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100208       };
100209     } catch (std::exception& e) {
100210       {
100211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100212       };
100213     } catch (Dali::DaliException e) {
100214       {
100215         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100216       };
100217     } catch (...) {
100218       {
100219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100220       };
100221     }
100222   }
100223
100224   jresult = result;
100225   return jresult;
100226 }
100227
100228
100229 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reference(void * jarg1) {
100230   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100231
100232   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100233   {
100234     try {
100235       (*arg1)->Reference();
100236     } catch (std::out_of_range& e) {
100237       {
100238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100239       };
100240     } catch (std::exception& e) {
100241       {
100242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100243       };
100244     } catch (Dali::DaliException e) {
100245       {
100246         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100247       };
100248     } catch (...) {
100249       {
100250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100251       };
100252     }
100253   }
100254
100255 }
100256
100257
100258 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Unreference(void * jarg1) {
100259   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100260
100261   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100262   {
100263     try {
100264       (*arg1)->Unreference();
100265     } catch (std::out_of_range& e) {
100266       {
100267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100268       };
100269     } catch (std::exception& e) {
100270       {
100271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100272       };
100273     } catch (Dali::DaliException e) {
100274       {
100275         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100276       };
100277     } catch (...) {
100278       {
100279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100280       };
100281     }
100282   }
100283
100284 }
100285
100286
100287 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_ReferenceCount(void * jarg1) {
100288   int jresult ;
100289   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100290   int result;
100291
100292   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100293   {
100294     try {
100295       result = (int)(*arg1)->ReferenceCount();
100296     } catch (std::out_of_range& e) {
100297       {
100298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100299       };
100300     } catch (std::exception& e) {
100301       {
100302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100303       };
100304     } catch (Dali::DaliException e) {
100305       {
100306         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100307       };
100308     } catch (...) {
100309       {
100310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100311       };
100312     }
100313   }
100314
100315   jresult = result;
100316   return jresult;
100317 }
100318
100319
100320 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Empty(void * jarg1) {
100321   unsigned int jresult ;
100322   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100323   bool result;
100324
100325   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100326   {
100327     try {
100328       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
100329     } catch (std::out_of_range& e) {
100330       {
100331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100332       };
100333     } catch (std::exception& e) {
100334       {
100335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100336       };
100337     } catch (Dali::DaliException e) {
100338       {
100339         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100340       };
100341     } catch (...) {
100342       {
100343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100344       };
100345     }
100346   }
100347
100348   jresult = result;
100349   return jresult;
100350 }
100351
100352
100353 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_GetConnectionCount(void * jarg1) {
100354   unsigned long jresult ;
100355   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100356   std::size_t result;
100357
100358   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100359   {
100360     try {
100361       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
100362     } catch (std::out_of_range& e) {
100363       {
100364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100365       };
100366     } catch (std::exception& e) {
100367       {
100368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100369       };
100370     } catch (Dali::DaliException e) {
100371       {
100372         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100373       };
100374     } catch (...) {
100375       {
100376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100377       };
100378     }
100379   }
100380
100381   jresult = (unsigned long)result;
100382   return jresult;
100383 }
100384
100385
100386 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Connect(void * jarg1, void * jarg2) {
100387   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100388   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
100389
100390   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100391   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
100392   {
100393     try {
100394       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
100395     } catch (std::out_of_range& e) {
100396       {
100397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100398       };
100399     } catch (std::exception& e) {
100400       {
100401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100402       };
100403     } catch (Dali::DaliException e) {
100404       {
100405         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100406       };
100407     } catch (...) {
100408       {
100409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100410       };
100411     }
100412   }
100413
100414 }
100415
100416
100417 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Disconnect(void * jarg1, void * jarg2) {
100418   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100419   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
100420
100421   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100422   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
100423   {
100424     try {
100425       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
100426     } catch (std::out_of_range& e) {
100427       {
100428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100429       };
100430     } catch (std::exception& e) {
100431       {
100432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100433       };
100434     } catch (Dali::DaliException e) {
100435       {
100436         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100437       };
100438     } catch (...) {
100439       {
100440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100441       };
100442     }
100443   }
100444
100445 }
100446
100447
100448 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Emit(void * jarg1, void * jarg2) {
100449   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100450   Dali::Toolkit::Control arg2 ;
100451   Dali::Toolkit::Control *argp2 ;
100452
100453   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100454   argp2 = (Dali::Toolkit::Control *)jarg2;
100455   if (!argp2) {
100456     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
100457     return ;
100458   }
100459   arg2 = *argp2;
100460   {
100461     try {
100462       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
100463     } catch (std::out_of_range& e) {
100464       {
100465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100466       };
100467     } catch (std::exception& e) {
100468       {
100469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100470       };
100471     } catch (Dali::DaliException e) {
100472       {
100473         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100474       };
100475     } catch (...) {
100476       {
100477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100478       };
100479     }
100480   }
100481
100482 }
100483
100484
100485 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewResourceReadySignal() {
100486   void * jresult ;
100487   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
100488
100489   {
100490     try {
100491       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
100492     } catch (std::out_of_range& e) {
100493       {
100494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100495       };
100496     } catch (std::exception& e) {
100497       {
100498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100499       };
100500     } catch (Dali::DaliException e) {
100501       {
100502         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100503       };
100504     } catch (...) {
100505       {
100506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100507       };
100508     }
100509   }
100510
100511   jresult = (void *)result;
100512   return jresult;
100513 }
100514
100515
100516 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewResourceReadySignal(void * jarg1) {
100517   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100518
100519   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100520   {
100521     try {
100522       delete arg1;
100523     } catch (std::out_of_range& e) {
100524       {
100525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100526       };
100527     } catch (std::exception& e) {
100528       {
100529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100530       };
100531     } catch (Dali::DaliException e) {
100532       {
100533         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100534       };
100535     } catch (...) {
100536       {
100537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100538       };
100539     }
100540   }
100541
100542 }
100543
100544 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_GetRefObjectPtr(Dali::BaseHandle *arg1) {
100545   Dali::RefObject *result = NULL;
100546
100547   if (arg1)
100548   {
100549     result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
100550   }
100551   return result;
100552 }
100553
100554 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_BaseObject_SWIGUpcast(Dali::BaseObject *jarg1) {
100555     return (Dali::RefObject *)jarg1;
100556 }
100557
100558 SWIGEXPORT Dali::SignalObserver * SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SWIGUpcast(Dali::ConnectionTrackerInterface *jarg1) {
100559     return (Dali::SignalObserver *)jarg1;
100560 }
100561
100562 SWIGEXPORT Dali::ConnectionTrackerInterface * SWIGSTDCALL CSharp_Dali_ConnectionTracker_SWIGUpcast(Dali::ConnectionTracker *jarg1) {
100563     return (Dali::ConnectionTrackerInterface *)jarg1;
100564 }
100565
100566 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ObjectRegistry_SWIGUpcast(Dali::ObjectRegistry *jarg1) {
100567     return (Dali::BaseHandle *)jarg1;
100568 }
100569
100570 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyCondition_SWIGUpcast(Dali::PropertyCondition *jarg1) {
100571     return (Dali::BaseHandle *)jarg1;
100572 }
100573
100574 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyNotification_SWIGUpcast(Dali::PropertyNotification *jarg1) {
100575     return (Dali::BaseHandle *)jarg1;
100576 }
100577
100578 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Handle_SWIGUpcast(Dali::Handle *jarg1) {
100579     return (Dali::BaseHandle *)jarg1;
100580 }
100581
100582 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeInfo_SWIGUpcast(Dali::TypeInfo *jarg1) {
100583     return (Dali::BaseHandle *)jarg1;
100584 }
100585
100586 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeRegistry_SWIGUpcast(Dali::TypeRegistry *jarg1) {
100587     return (Dali::BaseHandle *)jarg1;
100588 }
100589
100590 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Image_SWIGUpcast(Dali::Image *jarg1) {
100591     return (Dali::BaseHandle *)jarg1;
100592 }
100593
100594 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelData_SWIGUpcast(Dali::PixelData *jarg1) {
100595     return (Dali::BaseHandle *)jarg1;
100596 }
100597
100598 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Texture_SWIGUpcast(Dali::Texture *jarg1) {
100599     return (Dali::BaseHandle *)jarg1;
100600 }
100601
100602 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Sampler_SWIGUpcast(Dali::Sampler *jarg1) {
100603     return (Dali::BaseHandle *)jarg1;
100604 }
100605
100606 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TextureSet_SWIGUpcast(Dali::TextureSet *jarg1) {
100607     return (Dali::BaseHandle *)jarg1;
100608 }
100609
100610 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyBuffer_SWIGUpcast(Dali::PropertyBuffer *jarg1) {
100611     return (Dali::BaseHandle *)jarg1;
100612 }
100613
100614 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Geometry_SWIGUpcast(Dali::Geometry *jarg1) {
100615     return (Dali::BaseHandle *)jarg1;
100616 }
100617
100618 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Shader_SWIGUpcast(Dali::Shader *jarg1) {
100619     return (Dali::Handle *)jarg1;
100620 }
100621
100622 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Renderer_SWIGUpcast(Dali::Renderer *jarg1) {
100623     return (Dali::Handle *)jarg1;
100624 }
100625
100626 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_FrameBuffer_SWIGUpcast(Dali::FrameBuffer *jarg1) {
100627     return (Dali::BaseHandle *)jarg1;
100628 }
100629
100630 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_RenderTaskList_SWIGUpcast(Dali::RenderTaskList *jarg1) {
100631     return (Dali::BaseHandle *)jarg1;
100632 }
100633
100634 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_RenderTask_SWIGUpcast(Dali::RenderTask *jarg1) {
100635     return (Dali::Handle *)jarg1;
100636 }
100637
100638 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Touch_SWIGUpcast(Dali::TouchData *jarg1) {
100639     return (Dali::BaseHandle *)jarg1;
100640 }
100641
100642 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_GestureDetector_SWIGUpcast(Dali::GestureDetector *jarg1) {
100643     return (Dali::Handle *)jarg1;
100644 }
100645
100646 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SWIGUpcast(Dali::LongPressGestureDetector *jarg1) {
100647     return (Dali::GestureDetector *)jarg1;
100648 }
100649
100650 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_LongPressGesture_SWIGUpcast(Dali::LongPressGesture *jarg1) {
100651     return (Dali::Gesture *)jarg1;
100652 }
100653
100654 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Actor_SWIGUpcast(Dali::Actor *jarg1) {
100655     return (Dali::Handle *)jarg1;
100656 }
100657
100658 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_Layer_SWIGUpcast(Dali::Layer *jarg1) {
100659     return (Dali::Actor *)jarg1;
100660 }
100661
100662 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Stage_SWIGUpcast(Dali::Stage *jarg1) {
100663     return (Dali::BaseHandle *)jarg1;
100664 }
100665
100666 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_CustomActorImpl_SWIGUpcast(Dali::CustomActorImpl *jarg1) {
100667     return (Dali::RefObject *)jarg1;
100668 }
100669
100670 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CustomActor_SWIGUpcast(Dali::CustomActor *jarg1) {
100671     return (Dali::Actor *)jarg1;
100672 }
100673
100674 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PanGestureDetector_SWIGUpcast(Dali::PanGestureDetector *jarg1) {
100675     return (Dali::GestureDetector *)jarg1;
100676 }
100677
100678 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PanGesture_SWIGUpcast(Dali::PanGesture *jarg1) {
100679     return (Dali::Gesture *)jarg1;
100680 }
100681
100682 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_SWIGUpcast(Dali::PinchGestureDetector *jarg1) {
100683     return (Dali::GestureDetector *)jarg1;
100684 }
100685
100686 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PinchGesture_SWIGUpcast(Dali::PinchGesture *jarg1) {
100687     return (Dali::Gesture *)jarg1;
100688 }
100689
100690 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_TapGestureDetector_SWIGUpcast(Dali::TapGestureDetector *jarg1) {
100691     return (Dali::GestureDetector *)jarg1;
100692 }
100693
100694 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_TapGesture_SWIGUpcast(Dali::TapGesture *jarg1) {
100695     return (Dali::Gesture *)jarg1;
100696 }
100697
100698 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyFrames_SWIGUpcast(Dali::KeyFrames *jarg1) {
100699     return (Dali::BaseHandle *)jarg1;
100700 }
100701
100702 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Path_SWIGUpcast(Dali::Path *jarg1) {
100703     return (Dali::Handle *)jarg1;
100704 }
100705
100706 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_LinearConstrainer_SWIGUpcast(Dali::LinearConstrainer *jarg1) {
100707     return (Dali::Handle *)jarg1;
100708 }
100709
100710 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_PathConstrainer_SWIGUpcast(Dali::PathConstrainer *jarg1) {
100711     return (Dali::Handle *)jarg1;
100712 }
100713
100714 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_BufferImage_SWIGUpcast(Dali::BufferImage *jarg1) {
100715     return (Dali::Image *)jarg1;
100716 }
100717
100718 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_SWIGUpcast(Dali::EncodedBufferImage *jarg1) {
100719     return (Dali::Image *)jarg1;
100720 }
100721
100722 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_NativeImage_SWIGUpcast(Dali::NativeImage *jarg1) {
100723     return (Dali::Image *)jarg1;
100724 }
100725
100726 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_NativeImageInterface_SWIGUpcast(Dali::NativeImageInterface *jarg1) {
100727     return (Dali::RefObject *)jarg1;
100728 }
100729
100730 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_ResourceImage_SWIGUpcast(Dali::ResourceImage *jarg1) {
100731     return (Dali::Image *)jarg1;
100732 }
100733
100734 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_FrameBufferImage_SWIGUpcast(Dali::FrameBufferImage *jarg1) {
100735     return (Dali::Image *)jarg1;
100736 }
100737
100738 SWIGEXPORT Dali::ResourceImage * SWIGSTDCALL CSharp_Dali_NinePatchImage_SWIGUpcast(Dali::NinePatchImage *jarg1) {
100739     return (Dali::ResourceImage *)jarg1;
100740 }
100741
100742 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CameraActor_SWIGUpcast(Dali::CameraActor *jarg1) {
100743     return (Dali::Actor *)jarg1;
100744 }
100745
100746 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Timer_SWIGUpcast(Dali::Timer *jarg1) {
100747     return (Dali::BaseHandle *)jarg1;
100748 }
100749
100750 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_SWIGUpcast(Dali::DragAndDropDetector *jarg1) {
100751     return (Dali::BaseHandle *)jarg1;
100752 }
100753
100754
100755 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Builder_SWIGUpcast(Dali::Toolkit::Builder *jarg1) {
100756     return (Dali::BaseHandle *)jarg1;
100757 }
100758
100759 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TransitionData_SWIGUpcast(Dali::Toolkit::TransitionData *jarg1) {
100760     return (Dali::BaseHandle *)jarg1;
100761 }
100762
100763 SWIGEXPORT Dali::CustomActorImpl * SWIGSTDCALL CSharp_Dali_ViewImpl_SWIGUpcast(Dali::Toolkit::Internal::Control *jarg1) {
100764     return (Dali::CustomActorImpl *)jarg1;
100765 }
100766
100767 SWIGEXPORT Dali::CustomActor * SWIGSTDCALL CSharp_Dali_View_SWIGUpcast(Dali::Toolkit::Control *jarg1) {
100768     return (Dali::CustomActor *)jarg1;
100769 }
100770
100771 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SWIGUpcast(Dali::Toolkit::KeyInputFocusManager *jarg1) {
100772     return (Dali::BaseHandle *)jarg1;
100773 }
100774
100775 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Alignment_SWIGUpcast(Dali::Toolkit::Alignment *jarg1) {
100776     return (Dali::Toolkit::Control *)jarg1;
100777 }
100778
100779 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Button_SWIGUpcast(Dali::Toolkit::Button *jarg1) {
100780     return (Dali::Toolkit::Control *)jarg1;
100781 }
100782
100783 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_CheckBoxButton_SWIGUpcast(Dali::Toolkit::CheckBoxButton *jarg1) {
100784     return (Dali::Toolkit::Button *)jarg1;
100785 }
100786
100787 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_PushButton_SWIGUpcast(Dali::Toolkit::PushButton *jarg1) {
100788     return (Dali::Toolkit::Button *)jarg1;
100789 }
100790
100791 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_RadioButton_SWIGUpcast(Dali::Toolkit::RadioButton *jarg1) {
100792     return (Dali::Toolkit::Button *)jarg1;
100793 }
100794
100795 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_FlexContainer_SWIGUpcast(Dali::Toolkit::FlexContainer *jarg1) {
100796     return (Dali::Toolkit::Control *)jarg1;
100797 }
100798
100799 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ImageView_SWIGUpcast(Dali::Toolkit::ImageView *jarg1) {
100800     return (Dali::Toolkit::Control *)jarg1;
100801 }
100802
100803 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Model3dView_SWIGUpcast(Dali::Toolkit::Model3dView *jarg1) {
100804     return (Dali::Toolkit::Control *)jarg1;
100805 }
100806
100807 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ScrollBar_SWIGUpcast(Dali::Toolkit::ScrollBar *jarg1) {
100808     return (Dali::Toolkit::Control *)jarg1;
100809 }
100810
100811 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Scrollable_SWIGUpcast(Dali::Toolkit::Scrollable *jarg1) {
100812     return (Dali::Toolkit::Control *)jarg1;
100813 }
100814
100815 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_ItemLayout_SWIGUpcast(Dali::Toolkit::ItemLayout *jarg1) {
100816     return (Dali::RefObject *)jarg1;
100817 }
100818
100819 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ItemView_SWIGUpcast(Dali::Toolkit::ItemView *jarg1) {
100820     return (Dali::Toolkit::Scrollable *)jarg1;
100821 }
100822
100823 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ScrollViewEffect_SWIGUpcast(Dali::Toolkit::ScrollViewEffect *jarg1) {
100824     return (Dali::BaseHandle *)jarg1;
100825 }
100826
100827 SWIGEXPORT Dali::Toolkit::ScrollViewEffect * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_SWIGUpcast(Dali::Toolkit::ScrollViewPagePathEffect *jarg1) {
100828     return (Dali::Toolkit::ScrollViewEffect *)jarg1;
100829 }
100830
100831 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_Ruler_SWIGUpcast(Dali::Toolkit::Ruler *jarg1) {
100832     return (Dali::RefObject *)jarg1;
100833 }
100834
100835 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_DefaultRuler_SWIGUpcast(Dali::Toolkit::DefaultRuler *jarg1) {
100836     return (Dali::Toolkit::Ruler *)jarg1;
100837 }
100838
100839 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_FixedRuler_SWIGUpcast(Dali::Toolkit::FixedRuler *jarg1) {
100840     return (Dali::Toolkit::Ruler *)jarg1;
100841 }
100842
100843 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ScrollView_SWIGUpcast(Dali::Toolkit::ScrollView *jarg1) {
100844     return (Dali::Toolkit::Scrollable *)jarg1;
100845 }
100846
100847 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TableView_SWIGUpcast(Dali::Toolkit::TableView *jarg1) {
100848     return (Dali::Toolkit::Control *)jarg1;
100849 }
100850
100851
100852 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextLabel_SWIGUpcast(Dali::Toolkit::TextLabel *jarg1) {
100853     return (Dali::Toolkit::Control *)jarg1;
100854 }
100855
100856 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AccessibilityManager_SWIGUpcast(Dali::Toolkit::AccessibilityManager *jarg1) {
100857     return (Dali::BaseHandle *)jarg1;
100858 }
100859
100860 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_StyleManager_SWIGUpcast(Dali::Toolkit::StyleManager *jarg1) {
100861     return (Dali::BaseHandle *)jarg1;
100862 }
100863
100864 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Slider_SWIGUpcast(Dali::Toolkit::Slider *jarg1) {
100865     return (Dali::Toolkit::Control *)jarg1;
100866 }
100867
100868 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_VideoView_SWIGUpcast(Dali::Toolkit::VideoView *jarg1) {
100869     return (Dali::Toolkit::Control *)jarg1;
100870 }
100871
100872 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Popup_SWIGUpcast(Dali::Toolkit::Popup *jarg1) {
100873     return (Dali::Toolkit::Control *)jarg1;
100874 }
100875
100876 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ProgressBar_SWIGUpcast(Dali::Toolkit::ProgressBar *jarg1) {
100877     return (Dali::Toolkit::Control *)jarg1;
100878 }
100879
100880 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_GaussianBlurView_SWIGUpcast(Dali::Toolkit::GaussianBlurView *jarg1) {
100881     return (Dali::Toolkit::Control *)jarg1;
100882 }
100883
100884 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_PageTurnView_SWIGUpcast(Dali::Toolkit::PageTurnView *jarg1) {
100885     return (Dali::Toolkit::Control *)jarg1;
100886 }
100887
100888 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_SWIGUpcast(Dali::Toolkit::PageTurnLandscapeView *jarg1) {
100889     return (Dali::Toolkit::PageTurnView *)jarg1;
100890 }
100891
100892 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_SWIGUpcast(Dali::Toolkit::PageTurnPortraitView *jarg1) {
100893     return (Dali::Toolkit::PageTurnView *)jarg1;
100894 }
100895
100896 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_ToggleButton_SWIGUpcast(Dali::Toolkit::ToggleButton *jarg1) {
100897     return (Dali::Toolkit::Button *)jarg1;
100898 }
100899
100900 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualBase_SWIGUpcast(Dali::Toolkit::Visual::Base *jarg1) {
100901     return (Dali::BaseHandle *)jarg1;
100902 }
100903
100904 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualFactory_SWIGUpcast(Dali::Toolkit::VisualFactory *jarg1) {
100905     return (Dali::BaseHandle *)jarg1;
100906 }
100907
100908 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_SWIGUpcast(Dali::Toolkit::AsyncImageLoader *jarg1) {
100909     return (Dali::BaseHandle *)jarg1;
100910 }
100911
100912 /*
100913  * Widget binding
100914  */
100915 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Widget_SWIGUpcast(Dali::Widget *jarg1) {
100916     return (Dali::BaseHandle *)jarg1;
100917 }
100918
100919 SWIGEXPORT Dali::BaseObject * SWIGSTDCALL CSharp_Dali_WidgetImpl_SWIGUpcast(Dali::Internal::Adaptor::Widget *jarg1) {
100920     return (Dali::BaseObject *)jarg1;
100921 }
100922
100923 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_New__SWIG_0() {
100924   void * jresult ;
100925   Dali::Widget result;
100926
100927   {
100928     try {
100929       result = Dali::Widget::New();
100930     } catch (std::out_of_range& e) {
100931       {
100932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100933       };
100934     } catch (std::exception& e) {
100935       {
100936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100937       };
100938     } catch (...) {
100939       {
100940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100941       };
100942     }
100943   }
100944   jresult = new Dali::Widget((const Dali::Widget &)result);
100945   return jresult;
100946 }
100947
100948
100949 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_New__SWIG_1(void * jarg1) {
100950   void * jresult ;
100951   Dali::Internal::Adaptor::Widget *arg1 = 0 ;
100952   Dali::Widget result;
100953
100954   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100955
100956   if (!arg1) {
100957     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Internal::Adaptor::Widget & type is null", 0);
100958     return 0;
100959   }
100960   {
100961     try {
100962       jresult = new Dali::Widget(arg1);
100963     } catch (std::out_of_range& e) {
100964       {
100965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100966       };
100967     } catch (std::exception& e) {
100968       {
100969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100970       };
100971     } catch (...) {
100972       {
100973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100974       };
100975     }
100976   }
100977   return jresult;
100978 }
100979
100980
100981 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Widget() {
100982   void * jresult ;
100983   Dali::Widget *result = 0 ;
100984
100985   {
100986     try {
100987       result = (Dali::Widget *)new Dali::Widget();
100988     } catch (std::out_of_range& e) {
100989       {
100990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100991       };
100992     } catch (std::exception& e) {
100993       {
100994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100995       };
100996     } catch (...) {
100997       {
100998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100999       };
101000     }
101001   }
101002   jresult = (void *)result;
101003   return jresult;
101004 }
101005
101006
101007 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_Assign(void * jarg1, void * jarg2) {
101008   void * jresult ;
101009   Dali::Widget *arg1 = (Dali::Widget *) 0 ;
101010   Dali::Widget *arg2 = 0 ;
101011   Dali::Widget *result = 0 ;
101012
101013   arg1 = (Dali::Widget *)jarg1;
101014   arg2 = (Dali::Widget *)jarg2;
101015   if (!arg2) {
101016     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Widget const & type is null", 0);
101017     return 0;
101018   }
101019   {
101020     try {
101021       result = (Dali::Widget *) &(arg1)->operator =((Dali::Widget const &)*arg2);
101022     } catch (std::out_of_range& e) {
101023       {
101024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101025       };
101026     } catch (std::exception& e) {
101027       {
101028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101029       };
101030     } catch (...) {
101031       {
101032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101033       };
101034     }
101035   }
101036   jresult = (void *)result;
101037   return jresult;
101038 }
101039
101040
101041 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Widget(void * jarg1) {
101042   Dali::Widget *arg1 = (Dali::Widget *) 0 ;
101043
101044   arg1 = (Dali::Widget *)jarg1;
101045   {
101046     try {
101047       delete arg1;
101048     } catch (std::out_of_range& e) {
101049       {
101050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101051       };
101052     } catch (std::exception& e) {
101053       {
101054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101055       };
101056     } catch (...) {
101057       {
101058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101059       };
101060     }
101061   }
101062 }
101063
101064
101065 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetImpl_New() {
101066   void * jresult ;
101067   SwigDirector_WidgetImpl* result;
101068   {
101069     try {
101070       result = new SwigDirector_WidgetImpl();
101071     } catch (std::out_of_range& e) {
101072       {
101073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101074       };
101075     } catch (std::exception& e) {
101076       {
101077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101078       };
101079     } catch (...) {
101080       {
101081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101082       };
101083     }
101084   }
101085   jresult = result;
101086   return jresult;
101087 }
101088
101089
101090 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnCreate(void * jarg1, char * jarg2, void * jarg3) {
101091   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101092   std::string *arg2 = 0 ;
101093   Dali::Window arg3 ;
101094   Dali::Window *argp3 ;
101095
101096   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101097   if (!jarg2) {
101098     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101099     return ;
101100   }
101101   std::string arg2_str(jarg2);
101102   arg2 = &arg2_str;
101103   argp3 = (Dali::Window *)jarg3;
101104   if (!argp3) {
101105     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
101106     return ;
101107   }
101108   arg3 = *argp3;
101109   {
101110     try {
101111       (arg1)->OnCreate((std::string const &)*arg2,arg3);
101112     } catch (std::out_of_range& e) {
101113       {
101114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101115       };
101116     } catch (std::exception& e) {
101117       {
101118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101119       };
101120     } catch (...) {
101121       {
101122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101123       };
101124     }
101125   }
101126 }
101127
101128 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnCreateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, void * jarg3) {
101129   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101130   std::string *arg2 = 0 ;
101131   Dali::Window arg3 ;
101132   Dali::Window *argp3 ;
101133
101134   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101135   if (!jarg2) {
101136     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101137     return ;
101138   }
101139   std::string arg2_str(jarg2);
101140   arg2 = &arg2_str;
101141   argp3 = (Dali::Window *)jarg3;
101142   if (!argp3) {
101143     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
101144     return ;
101145   }
101146   arg3 = *argp3;
101147   {
101148     try {
101149       (arg1)->Dali::Internal::Adaptor::Widget::OnCreate((std::string const &)*arg2,arg3);
101150     } catch (std::out_of_range& e) {
101151       {
101152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101153       };
101154     } catch (std::exception& e) {
101155       {
101156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101157       };
101158     } catch (...) {
101159       {
101160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101161       };
101162     }
101163   }
101164 }
101165
101166
101167 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnTerminate(void * jarg1, char * jarg2, int jarg3) {
101168   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101169   std::string *arg2 = 0 ;
101170   Dali::Widget::Termination arg3 ;
101171
101172   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101173   if (!jarg2) {
101174     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101175     return ;
101176   }
101177   std::string arg2_str(jarg2);
101178   arg2 = &arg2_str;
101179   arg3 = (Dali::Widget::Termination)jarg3;
101180   {
101181     try {
101182       (arg1)->OnTerminate((std::string const &)*arg2,arg3);
101183     } catch (std::out_of_range& e) {
101184       {
101185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101186       };
101187     } catch (std::exception& e) {
101188       {
101189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101190       };
101191     } catch (...) {
101192       {
101193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101194       };
101195     }
101196   }
101197 }
101198
101199 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnTerminateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, int jarg3) {
101200   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101201   std::string *arg2 = 0 ;
101202   Dali::Widget::Termination arg3 ;
101203
101204   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101205   if (!jarg2) {
101206     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101207     return ;
101208   }
101209   std::string arg2_str(jarg2);
101210   arg2 = &arg2_str;
101211   arg3 = (Dali::Widget::Termination)jarg3;
101212   {
101213     try {
101214       (arg1)->Dali::Internal::Adaptor::Widget::OnTerminate((std::string const &)*arg2,arg3);
101215     } catch (std::out_of_range& e) {
101216       {
101217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101218       };
101219     } catch (std::exception& e) {
101220       {
101221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101222       };
101223     } catch (...) {
101224       {
101225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101226       };
101227     }
101228   }
101229 }
101230
101231
101232 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnPause(void * jarg1) {
101233   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101234
101235   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101236   {
101237     try {
101238       (arg1)->OnPause();
101239     } catch (std::out_of_range& e) {
101240       {
101241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101242       };
101243     } catch (std::exception& e) {
101244       {
101245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101246       };
101247     } catch (...) {
101248       {
101249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101250       };
101251     }
101252   }
101253 }
101254
101255 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnPauseSwigExplicitWidgetImpl(void * jarg1) {
101256   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101257
101258   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101259   {
101260     try {
101261       (arg1)->Dali::Internal::Adaptor::Widget::OnPause();
101262     } catch (std::out_of_range& e) {
101263       {
101264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101265       };
101266     } catch (std::exception& e) {
101267       {
101268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101269       };
101270     } catch (...) {
101271       {
101272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101273       };
101274     }
101275   }
101276 }
101277
101278
101279 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResume(void * jarg1) {
101280   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101281
101282   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101283   {
101284     try {
101285       (arg1)->OnResume();
101286     } catch (std::out_of_range& e) {
101287       {
101288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101289       };
101290     } catch (std::exception& e) {
101291       {
101292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101293       };
101294     } catch (...) {
101295       {
101296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101297       };
101298     }
101299   }
101300 }
101301
101302
101303 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResumeSwigExplicitWidgetImpl(void * jarg1) {
101304   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101305
101306   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101307   {
101308     try {
101309       (arg1)->Dali::Internal::Adaptor::Widget::OnResume();
101310     } catch (std::out_of_range& e) {
101311       {
101312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101313       };
101314     } catch (std::exception& e) {
101315       {
101316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101317       };
101318     } catch (...) {
101319       {
101320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101321       };
101322     }
101323   }
101324 }
101325
101326
101327 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResize(void * jarg1, void * jarg2) {
101328   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101329   Dali::Window arg2 ;
101330   Dali::Window *argp2 ;
101331
101332   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101333   argp2 = (Dali::Window *)jarg2;
101334   if (!argp2) {
101335     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
101336     return ;
101337   }
101338   arg2 = *argp2;
101339   {
101340     try {
101341       (arg1)->OnResize(arg2);
101342     } catch (std::out_of_range& e) {
101343       {
101344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101345       };
101346     } catch (std::exception& e) {
101347       {
101348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101349       };
101350     } catch (...) {
101351       {
101352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101353       };
101354     }
101355   }
101356 }
101357
101358 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResizeSwigExplicitWidgetImpl(void * jarg1, void * jarg2) {
101359   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101360   Dali::Window arg2 ;
101361   Dali::Window *argp2 ;
101362
101363   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101364   argp2 = (Dali::Window *)jarg2;
101365   if (!argp2) {
101366     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
101367     return ;
101368   }
101369   arg2 = *argp2;
101370   {
101371     try {
101372       (arg1)->Dali::Internal::Adaptor::Widget::OnResize(arg2);
101373     } catch (std::out_of_range& e) {
101374       {
101375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101376       };
101377     } catch (std::exception& e) {
101378       {
101379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101380       };
101381     } catch (...) {
101382       {
101383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101384       };
101385     }
101386   }
101387 }
101388
101389
101390 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnUpdate(void * jarg1, char * jarg2, int jarg3) {
101391   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101392   std::string *arg2 = 0 ;
101393   int arg3 ;
101394
101395   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101396   if (!jarg2) {
101397     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101398     return ;
101399   }
101400   std::string arg2_str(jarg2);
101401   arg2 = &arg2_str;
101402   arg3 = (int)jarg3;
101403   {
101404     try {
101405       (arg1)->OnUpdate((std::string const &)*arg2,arg3);
101406     } catch (std::out_of_range& e) {
101407       {
101408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101409       };
101410     } catch (std::exception& e) {
101411       {
101412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101413       };
101414     } catch (...) {
101415       {
101416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101417       };
101418     }
101419   }
101420 }
101421
101422 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnUpdateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, int jarg3) {
101423   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101424   std::string *arg2 = 0 ;
101425   int arg3 ;
101426
101427   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101428   if (!jarg2) {
101429     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101430     return ;
101431   }
101432   std::string arg2_str(jarg2);
101433   arg2 = &arg2_str;
101434   arg3 = (int)jarg3;
101435   {
101436     try {
101437       (arg1)->Dali::Internal::Adaptor::Widget::OnUpdate((std::string const &)*arg2,arg3);
101438     } catch (std::out_of_range& e) {
101439       {
101440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101441       };
101442     } catch (std::exception& e) {
101443       {
101444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101445       };
101446     } catch (...) {
101447       {
101448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101449       };
101450     }
101451   }
101452 }
101453
101454
101455 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
101456   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101457   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
101458   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
101459
101460   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101461   arg2 = (Dali::SlotObserver *)jarg2;
101462   arg3 = (Dali::CallbackBase *)jarg3;
101463   {
101464     try {
101465       (arg1)->SignalConnected(arg2,arg3);
101466     } catch (std::out_of_range& e) {
101467       {
101468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101469       };
101470     } catch (std::exception& e) {
101471       {
101472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101473       };
101474     } catch (...) {
101475       {
101476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101477       };
101478     }
101479   }
101480 }
101481
101482 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalConnectedSwigExplicitWidgetImpl(void * jarg1, void * jarg2, void * jarg3) {
101483   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101484   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
101485   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
101486
101487   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101488   arg2 = (Dali::SlotObserver *)jarg2;
101489   arg3 = (Dali::CallbackBase *)jarg3;
101490   {
101491     try {
101492       (arg1)->Dali::Internal::Adaptor::Widget::SignalConnected(arg2,arg3);
101493     } catch (std::out_of_range& e) {
101494       {
101495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101496       };
101497     } catch (std::exception& e) {
101498       {
101499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101500       };
101501     } catch (...) {
101502       {
101503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101504       };
101505     }
101506   }
101507 }
101508
101509
101510 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
101511   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101512   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
101513   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
101514
101515   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101516   arg2 = (Dali::SlotObserver *)jarg2;
101517   arg3 = (Dali::CallbackBase *)jarg3;
101518   {
101519     try {
101520       (arg1)->SignalDisconnected(arg2,arg3);
101521     } catch (std::out_of_range& e) {
101522       {
101523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101524       };
101525     } catch (std::exception& e) {
101526       {
101527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101528       };
101529     } catch (...) {
101530       {
101531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101532       };
101533     }
101534   }
101535 }
101536
101537 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalDisconnectedSwigExplicitWidgetImpl(void * jarg1, void * jarg2, void * jarg3) {
101538   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101539   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
101540   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
101541
101542   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101543   arg2 = (Dali::SlotObserver *)jarg2;
101544   arg3 = (Dali::CallbackBase *)jarg3;
101545   {
101546     try {
101547       (arg1)->Dali::Internal::Adaptor::Widget::SignalDisconnected(arg2,arg3);
101548     } catch (std::out_of_range& e) {
101549       {
101550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101551       };
101552     } catch (std::exception& e) {
101553       {
101554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101555       };
101556     } catch (...) {
101557       {
101558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101559       };
101560     }
101561   }
101562 }
101563
101564 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SetContentInfo(void * jarg1, char * jarg2) {
101565   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101566   std::string *arg2 = 0 ;
101567
101568   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101569   if (!jarg2) {
101570     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101571     return ;
101572   }
101573   std::string arg2_str(jarg2);
101574   arg2 = &arg2_str;
101575   {
101576     try {
101577       (arg1)->SetContentInfo((std::string const &)*arg2);
101578     } catch (std::out_of_range& e) {
101579       {
101580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101581       };
101582     } catch (std::exception& e) {
101583       {
101584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101585       };
101586     } catch (...) {
101587       {
101588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101589       };
101590     }
101591   }
101592 }
101593
101594
101595 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SetImpl(void * jarg1, void * jarg2) {
101596   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101597   Dali::Internal::Adaptor::Widget::Impl *arg2 = (Dali::Internal::Adaptor::Widget::Impl *) 0 ;
101598
101599   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101600   arg2 = (Dali::Internal::Adaptor::Widget::Impl *)jarg2;
101601   {
101602     try {
101603       (arg1)->SetImpl(arg2);
101604     } catch (std::out_of_range& e) {
101605       {
101606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101607       };
101608     } catch (std::exception& e) {
101609       {
101610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101611       };
101612     } catch (...) {
101613       {
101614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101615       };
101616     }
101617   }
101618 }
101619
101620 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) {
101621
101622   SwigDirector_WidgetImpl *director = static_cast<SwigDirector_WidgetImpl *>(objarg);
101623   if (director) {
101624     director->swig_connect_director(callback0, callback1, callback2, callback3, callback4, callback5, callback6, callback7);
101625   }
101626 }
101627
101628 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_GetImplementation__SWIG_0(void * jarg1) {
101629   void * jresult ;
101630   Dali::Widget *arg1 = 0 ;
101631   SwigDirector_WidgetImpl *result = 0 ;
101632
101633   arg1 = (Dali::Widget *)jarg1;
101634   if (!arg1) {
101635     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Widget & type is null", 0);
101636     return 0;
101637   }
101638   {
101639     try {
101640       result = (SwigDirector_WidgetImpl *) &Dali::Internal::Adaptor::GetImplementation(*arg1);
101641     } catch (std::out_of_range& e) {
101642       {
101643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101644       };
101645     } catch (std::exception& e) {
101646       {
101647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101648       };
101649     } catch (...) {
101650       {
101651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101652       };
101653     }
101654   }
101655
101656   jresult = (void *)result;
101657   return jresult;
101658 }
101659
101660
101661 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetApplication_New(int jarg1, char * jarg2, char * jarg3) {
101662   void * jresult ;
101663   int *arg1 = (int *) 0 ;
101664   char ***arg2 ;
101665   std::string *arg3 = 0 ;
101666   Dali::WidgetApplication result;
101667   {
101668     int index = 0;
101669     int length = 0;
101670     char *retPtr;
101671     char *nextPtr;
101672     argWidgetC = jarg1;
101673     argWidgetV = new char*[jarg1 + 1];
101674
101675     retPtr = strtok_r( jarg2, " ", &nextPtr);
101676     if( retPtr )
101677     {
101678       length = strlen(retPtr);
101679     }
101680     argWidgetV[index] = new char[length + 1];
101681     if( retPtr )
101682     {
101683       strncpy(argWidgetV[index], retPtr, length);
101684     }
101685     argWidgetV[index][length] = '\0';
101686     index++;
101687
101688     while (index < jarg1)
101689     {
101690       length = 0;
101691       retPtr = strtok_r(NULL, " ", &nextPtr);
101692       if( retPtr )
101693       {
101694         length = strlen(retPtr);
101695       }
101696       argWidgetV[index] = new char[length + 1];
101697       if( retPtr )
101698       {
101699         strncpy(argWidgetV[index], retPtr, length);
101700       }
101701       argWidgetV[index][length] = '\0';
101702       index++;
101703     }
101704
101705     argWidgetV[jarg1] = NULL;
101706     argWidgetC = jarg1;
101707
101708     arg1 = &argWidgetC;
101709     arg2 = &argWidgetV;
101710   }
101711
101712   if (!jarg3) {
101713     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101714     return 0;
101715   }
101716   std::string arg3_str(jarg3);
101717   arg3 = &arg3_str;
101718   {
101719     try {
101720       result = Dali::WidgetApplication::New(arg1,arg2,(std::string const &)*arg3);
101721     } catch (std::out_of_range& e) {
101722       {
101723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101724       };
101725     } catch (std::exception& e) {
101726       {
101727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101728       };
101729     } catch (...) {
101730       {
101731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101732       };
101733     }
101734   }
101735   jresult = new Dali::WidgetApplication((const Dali::WidgetApplication &)result);
101736
101737   return jresult;
101738 }
101739
101740
101741 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WidgetApplication__SWIG_0() {
101742   void * jresult ;
101743   Dali::WidgetApplication *result = 0 ;
101744
101745   {
101746     try {
101747       result = (Dali::WidgetApplication *)new Dali::WidgetApplication();
101748     } catch (std::out_of_range& e) {
101749       {
101750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101751       };
101752     } catch (std::exception& e) {
101753       {
101754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101755       };
101756     } catch (...) {
101757       {
101758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101759       };
101760     }
101761   }
101762   jresult = (void *)result;
101763   return jresult;
101764 }
101765
101766
101767 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WidgetApplication__SWIG_1(void * jarg1) {
101768   void * jresult ;
101769   Dali::WidgetApplication *arg1 = 0 ;
101770   Dali::WidgetApplication *result = 0 ;
101771
101772   arg1 = (Dali::WidgetApplication *)jarg1;
101773   if (!arg1) {
101774     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WidgetApplication const & type is null", 0);
101775     return 0;
101776   }
101777   {
101778     try {
101779       result = (Dali::WidgetApplication *)new Dali::WidgetApplication((Dali::WidgetApplication const &)*arg1);
101780     } catch (std::out_of_range& e) {
101781       {
101782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101783       };
101784     } catch (std::exception& e) {
101785       {
101786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101787       };
101788     } catch (...) {
101789       {
101790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101791       };
101792     }
101793   }
101794   jresult = (void *)result;
101795   return jresult;
101796 }
101797
101798
101799 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetApplication_Assign(void * jarg1, void * jarg2) {
101800   void * jresult ;
101801   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
101802   Dali::WidgetApplication *arg2 = 0 ;
101803   Dali::WidgetApplication *result = 0 ;
101804
101805   arg1 = (Dali::WidgetApplication *)jarg1;
101806   arg2 = (Dali::WidgetApplication *)jarg2;
101807   if (!arg2) {
101808     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WidgetApplication const & type is null", 0);
101809     return 0;
101810   }
101811   {
101812     try {
101813       result = (Dali::WidgetApplication *) &(arg1)->operator =((Dali::WidgetApplication const &)*arg2);
101814     } catch (std::out_of_range& e) {
101815       {
101816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101817       };
101818     } catch (std::exception& e) {
101819       {
101820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101821       };
101822     } catch (...) {
101823       {
101824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101825       };
101826     }
101827   }
101828   jresult = (void *)result;
101829   return jresult;
101830 }
101831
101832
101833 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WidgetApplication(void * jarg1) {
101834   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
101835
101836   arg1 = (Dali::WidgetApplication *)jarg1;
101837   {
101838     try {
101839       delete arg1;
101840       if( argWidgetV )
101841       {
101842         // free string data
101843         for( int i=0; i < argWidgetC+1; i++)
101844         {
101845           delete [] argWidgetV[i];
101846         }
101847         delete [] argWidgetV;
101848       }
101849     } catch (std::out_of_range& e) {
101850       {
101851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101852       };
101853     } catch (std::exception& e) {
101854       {
101855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101856       };
101857     } catch (...) {
101858       {
101859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101860       };
101861     }
101862   }
101863 }
101864
101865
101866 typedef Dali::Widget*(SWIGSTDCALL *CSharpCreateWidgetFunction)(const std::string&);
101867 CSharpCreateWidgetFunction _CSharpCreateWidgetFunction = NULL;
101868
101869 static Dali::Widget SWIGSTDCALL WidgetFactoryFunction( const std::string& widgetName )
101870 {
101871   Widget* widget = _CSharpCreateWidgetFunction( widgetName.c_str() );
101872   return *widget;
101873 }
101874
101875 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetApplication_RegisterWidgetCreatingFunction(void * jarg1, char** jarg2, void * jarg3) {
101876   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
101877   std::string *arg2 = 0 ;
101878
101879   arg1 = (Dali::WidgetApplication *)jarg1;
101880   if (!jarg2) {
101881     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101882     return ;
101883   }
101884   std::string arg2_str(*jarg2);
101885   arg2 = &arg2_str;
101886
101887   if(!_CSharpCreateWidgetFunction)
101888   {
101889     _CSharpCreateWidgetFunction = (Dali::Widget*(*)(const std::string&))jarg3;
101890   }
101891
101892   {
101893     try {
101894       (arg1)->RegisterWidgetCreatingFunction((std::string const &)*arg2, WidgetFactoryFunction);
101895     } catch (std::out_of_range& e) {
101896       {
101897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101898       };
101899     } catch (std::exception& e) {
101900       {
101901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101902       };
101903     } catch (...) {
101904       {
101905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101906       };
101907     }
101908   }
101909
101910   //Typemap argout in c++ file.
101911   //This will convert c++ string to c# string
101912   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
101913 }
101914
101915
101916 //for PixelBuffer and ImageLoading
101917
101918 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelBuffer_SWIGUpcast(Dali::Devel::PixelBuffer *jarg1) {
101919     return (Dali::BaseHandle *)jarg1;
101920 }
101921
101922 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_New(unsigned int jarg1, unsigned int jarg2, int jarg3) {
101923   void * jresult ;
101924   unsigned int arg1 ;
101925   unsigned int arg2 ;
101926   Dali::Pixel::Format arg3 ;
101927   Dali::Devel::PixelBuffer result;
101928
101929   arg1 = (unsigned int)jarg1;
101930   arg2 = (unsigned int)jarg2;
101931   arg3 = (Dali::Pixel::Format)jarg3;
101932   {
101933     try {
101934       result = Dali::Devel::PixelBuffer::New(arg1,arg2,arg3);
101935     } catch (std::out_of_range& e) {
101936       {
101937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101938       };
101939     } catch (std::exception& e) {
101940       {
101941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101942       };
101943     } catch (...) {
101944       {
101945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101946       };
101947     }
101948   }
101949   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
101950   return jresult;
101951 }
101952
101953
101954 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelBuffer__SWIG_0() {
101955   void * jresult ;
101956   Dali::Devel::PixelBuffer *result = 0 ;
101957
101958   {
101959     try {
101960       result = (Dali::Devel::PixelBuffer *)new Dali::Devel::PixelBuffer();
101961     } catch (std::out_of_range& e) {
101962       {
101963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101964       };
101965     } catch (std::exception& e) {
101966       {
101967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101968       };
101969     } catch (...) {
101970       {
101971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101972       };
101973     }
101974   }
101975   jresult = (void *)result;
101976   return jresult;
101977 }
101978
101979
101980 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelBuffer(void * jarg1) {
101981   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101982
101983   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101984   {
101985     try {
101986       delete arg1;
101987     } catch (std::out_of_range& e) {
101988       {
101989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101990       };
101991     } catch (std::exception& e) {
101992       {
101993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101994       };
101995     } catch (...) {
101996       {
101997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101998       };
101999     }
102000   }
102001 }
102002
102003
102004 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelBuffer__SWIG_1(void * jarg1) {
102005   void * jresult ;
102006   Dali::Devel::PixelBuffer *arg1 = 0 ;
102007   Dali::Devel::PixelBuffer *result = 0 ;
102008
102009   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102010   if (!arg1) {
102011     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer const & type is null", 0);
102012     return 0;
102013   }
102014   {
102015     try {
102016       result = (Dali::Devel::PixelBuffer *)new Dali::Devel::PixelBuffer((Dali::Devel::PixelBuffer const &)*arg1);
102017     } catch (std::out_of_range& e) {
102018       {
102019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102020       };
102021     } catch (std::exception& e) {
102022       {
102023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102024       };
102025     } catch (...) {
102026       {
102027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102028       };
102029     }
102030   }
102031   jresult = (void *)result;
102032   return jresult;
102033 }
102034
102035
102036 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_Assign(void * jarg1, void * jarg2) {
102037   void * jresult ;
102038   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102039   Dali::Devel::PixelBuffer *arg2 = 0 ;
102040   Dali::Devel::PixelBuffer *result = 0 ;
102041
102042   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102043   arg2 = (Dali::Devel::PixelBuffer *)jarg2;
102044   if (!arg2) {
102045     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer const & type is null", 0);
102046     return 0;
102047   }
102048   {
102049     try {
102050       result = (Dali::Devel::PixelBuffer *) &(arg1)->operator =((Dali::Devel::PixelBuffer const &)*arg2);
102051     } catch (std::out_of_range& e) {
102052       {
102053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102054       };
102055     } catch (std::exception& e) {
102056       {
102057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102058       };
102059     } catch (...) {
102060       {
102061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102062       };
102063     }
102064   }
102065   jresult = (void *)result;
102066   return jresult;
102067 }
102068
102069
102070 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_Convert(void * jarg1) {
102071   void * jresult ;
102072   Dali::Devel::PixelBuffer *arg1 = 0 ;
102073   Dali::PixelData result;
102074
102075   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102076   if (!arg1) {
102077     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer & type is null", 0);
102078     return 0;
102079   }
102080   {
102081     try {
102082       result = Dali::Devel::PixelBuffer::Convert(*arg1);
102083     } catch (std::out_of_range& e) {
102084       {
102085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102086       };
102087     } catch (std::exception& e) {
102088       {
102089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102090       };
102091     } catch (...) {
102092       {
102093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102094       };
102095     }
102096   }
102097   jresult = new Dali::PixelData((const Dali::PixelData &)result);
102098   return jresult;
102099 }
102100
102101
102102 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_CreatePixelData(void * jarg1) {
102103   void * jresult ;
102104   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102105   Dali::PixelData result;
102106
102107   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102108   {
102109     try {
102110       result = ((Dali::Devel::PixelBuffer const *)arg1)->CreatePixelData();
102111     } catch (std::out_of_range& e) {
102112       {
102113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102114       };
102115     } catch (std::exception& e) {
102116       {
102117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102118       };
102119     } catch (...) {
102120       {
102121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102122       };
102123     }
102124   }
102125   jresult = new Dali::PixelData((const Dali::PixelData &)result);
102126   return jresult;
102127 }
102128
102129
102130 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_GetBuffer(void * jarg1) {
102131   void * jresult ;
102132   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102133   unsigned char *result = 0 ;
102134
102135   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102136   {
102137     try {
102138       result = (unsigned char *)(arg1)->GetBuffer();
102139     } catch (std::out_of_range& e) {
102140       {
102141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102142       };
102143     } catch (std::exception& e) {
102144       {
102145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102146       };
102147     } catch (...) {
102148       {
102149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102150       };
102151     }
102152   }
102153   jresult = (void *)result;
102154   return jresult;
102155 }
102156
102157
102158 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetWidth(void * jarg1) {
102159   unsigned int jresult ;
102160   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102161   unsigned int result;
102162
102163   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102164   {
102165     try {
102166       result = (unsigned int)((Dali::Devel::PixelBuffer const *)arg1)->GetWidth();
102167     } catch (std::out_of_range& e) {
102168       {
102169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102170       };
102171     } catch (std::exception& e) {
102172       {
102173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102174       };
102175     } catch (...) {
102176       {
102177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102178       };
102179     }
102180   }
102181   jresult = result;
102182   return jresult;
102183 }
102184
102185
102186 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetHeight(void * jarg1) {
102187   unsigned int jresult ;
102188   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102189   unsigned int result;
102190
102191   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102192   {
102193     try {
102194       result = (unsigned int)((Dali::Devel::PixelBuffer const *)arg1)->GetHeight();
102195     } catch (std::out_of_range& e) {
102196       {
102197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102198       };
102199     } catch (std::exception& e) {
102200       {
102201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102202       };
102203     } catch (...) {
102204       {
102205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102206       };
102207     }
102208   }
102209   jresult = result;
102210   return jresult;
102211 }
102212
102213
102214 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetPixelFormat(void * jarg1) {
102215   int jresult ;
102216   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102217   Dali::Pixel::Format result;
102218
102219   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102220   {
102221     try {
102222       result = (Dali::Pixel::Format)((Dali::Devel::PixelBuffer const *)arg1)->GetPixelFormat();
102223     } catch (std::out_of_range& e) {
102224       {
102225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102226       };
102227     } catch (std::exception& e) {
102228       {
102229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102230       };
102231     } catch (...) {
102232       {
102233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102234       };
102235     }
102236   }
102237   jresult = (int)result;
102238   return jresult;
102239 }
102240
102241
102242 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_0(void * jarg1, void * jarg2, float jarg3, unsigned int jarg4) {
102243   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102244   Dali::Devel::PixelBuffer arg2 ;
102245   float arg3 ;
102246   bool arg4 ;
102247   Dali::Devel::PixelBuffer *argp2 ;
102248
102249   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102250   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
102251   if (!argp2) {
102252     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
102253     return ;
102254   }
102255   arg2 = *argp2;
102256   arg3 = (float)jarg3;
102257   arg4 = jarg4 ? true : false;
102258   {
102259     try {
102260       (arg1)->ApplyMask(arg2,arg3,arg4);
102261     } catch (std::out_of_range& e) {
102262       {
102263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102264       };
102265     } catch (std::exception& e) {
102266       {
102267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102268       };
102269     } catch (...) {
102270       {
102271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102272       };
102273     }
102274   }
102275 }
102276
102277
102278 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
102279   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102280   Dali::Devel::PixelBuffer arg2 ;
102281   float arg3 ;
102282   Dali::Devel::PixelBuffer *argp2 ;
102283
102284   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102285   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
102286   if (!argp2) {
102287     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
102288     return ;
102289   }
102290   arg2 = *argp2;
102291   arg3 = (float)jarg3;
102292   {
102293     try {
102294       (arg1)->ApplyMask(arg2,arg3);
102295     } catch (std::out_of_range& e) {
102296       {
102297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102298       };
102299     } catch (std::exception& e) {
102300       {
102301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102302       };
102303     } catch (...) {
102304       {
102305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102306       };
102307     }
102308   }
102309 }
102310
102311
102312 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_2(void * jarg1, void * jarg2) {
102313   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102314   Dali::Devel::PixelBuffer arg2 ;
102315   Dali::Devel::PixelBuffer *argp2 ;
102316
102317   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102318   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
102319   if (!argp2) {
102320     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
102321     return ;
102322   }
102323   arg2 = *argp2;
102324   {
102325     try {
102326       (arg1)->ApplyMask(arg2);
102327     } catch (std::out_of_range& e) {
102328       {
102329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102330       };
102331     } catch (std::exception& e) {
102332       {
102333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102334       };
102335     } catch (...) {
102336       {
102337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102338       };
102339     }
102340   }
102341 }
102342
102343
102344 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyGaussianBlur(void * jarg1, float jarg2) {
102345   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102346   float arg2 ;
102347
102348   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102349   arg2 = (float)jarg2;
102350   {
102351     try {
102352       (arg1)->ApplyGaussianBlur(arg2);
102353     } catch (std::out_of_range& e) {
102354       {
102355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102356       };
102357     } catch (std::exception& e) {
102358       {
102359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102360       };
102361     } catch (...) {
102362       {
102363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102364       };
102365     }
102366   }
102367 }
102368
102369
102370 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_Crop(void * jarg1, unsigned short jarg2, unsigned short jarg3, unsigned short jarg4, unsigned short jarg5) {
102371   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102372   uint16_t arg2 ;
102373   uint16_t arg3 ;
102374   uint16_t arg4 ;
102375   uint16_t arg5 ;
102376
102377   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102378   arg2 = (uint16_t)jarg2;
102379   arg3 = (uint16_t)jarg3;
102380   arg4 = (uint16_t)jarg4;
102381   arg5 = (uint16_t)jarg5;
102382   {
102383     try {
102384       (arg1)->Crop(arg2,arg3,arg4,arg5);
102385     } catch (std::out_of_range& e) {
102386       {
102387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102388       };
102389     } catch (std::exception& e) {
102390       {
102391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102392       };
102393     } catch (...) {
102394       {
102395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102396       };
102397     }
102398   }
102399 }
102400
102401
102402 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_Resize(void * jarg1, unsigned short jarg2, unsigned short jarg3) {
102403   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102404   uint16_t arg2 ;
102405   uint16_t arg3 ;
102406
102407   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102408   arg2 = (uint16_t)jarg2;
102409   arg3 = (uint16_t)jarg3;
102410   {
102411     try {
102412       (arg1)->Resize(arg2,arg3);
102413     } catch (std::out_of_range& e) {
102414       {
102415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102416       };
102417     } catch (std::exception& e) {
102418       {
102419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102420       };
102421     } catch (...) {
102422       {
102423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102424       };
102425     }
102426   }
102427 }
102428
102429
102430 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
102431   void * jresult ;
102432   std::string *arg1 = 0 ;
102433   Dali::ImageDimensions arg2 ;
102434   Dali::FittingMode::Type arg3 ;
102435   Dali::SamplingMode::Type arg4 ;
102436   bool arg5 ;
102437   Dali::ImageDimensions *argp2 ;
102438   Dali::Devel::PixelBuffer result;
102439
102440   if (!jarg1) {
102441     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102442     return 0;
102443   }
102444   std::string arg1_str(jarg1);
102445   arg1 = &arg1_str;
102446   argp2 = (Dali::ImageDimensions *)jarg2;
102447   if (!argp2) {
102448     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
102449     return 0;
102450   }
102451   arg2 = *argp2;
102452   arg3 = (Dali::FittingMode::Type)jarg3;
102453   arg4 = (Dali::SamplingMode::Type)jarg4;
102454   arg5 = jarg5 ? true : false;
102455   {
102456     try {
102457       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3,arg4,arg5);
102458     } catch (std::out_of_range& e) {
102459       {
102460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102461       };
102462     } catch (std::exception& e) {
102463       {
102464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102465       };
102466     } catch (...) {
102467       {
102468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102469       };
102470     }
102471   }
102472   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
102473
102474   return jresult;
102475 }
102476
102477
102478 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
102479   void * jresult ;
102480   std::string *arg1 = 0 ;
102481   Dali::ImageDimensions arg2 ;
102482   Dali::FittingMode::Type arg3 ;
102483   Dali::SamplingMode::Type arg4 ;
102484   Dali::ImageDimensions *argp2 ;
102485   Dali::Devel::PixelBuffer result;
102486
102487   if (!jarg1) {
102488     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102489     return 0;
102490   }
102491   std::string arg1_str(jarg1);
102492   arg1 = &arg1_str;
102493   argp2 = (Dali::ImageDimensions *)jarg2;
102494   if (!argp2) {
102495     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
102496     return 0;
102497   }
102498   arg2 = *argp2;
102499   arg3 = (Dali::FittingMode::Type)jarg3;
102500   arg4 = (Dali::SamplingMode::Type)jarg4;
102501   {
102502     try {
102503       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3,arg4);
102504     } catch (std::out_of_range& e) {
102505       {
102506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102507       };
102508     } catch (std::exception& e) {
102509       {
102510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102511       };
102512     } catch (...) {
102513       {
102514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102515       };
102516     }
102517   }
102518   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
102519
102520   return jresult;
102521 }
102522
102523
102524 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
102525   void * jresult ;
102526   std::string *arg1 = 0 ;
102527   Dali::ImageDimensions arg2 ;
102528   Dali::FittingMode::Type arg3 ;
102529   Dali::ImageDimensions *argp2 ;
102530   Dali::Devel::PixelBuffer result;
102531
102532   if (!jarg1) {
102533     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102534     return 0;
102535   }
102536   std::string arg1_str(jarg1);
102537   arg1 = &arg1_str;
102538   argp2 = (Dali::ImageDimensions *)jarg2;
102539   if (!argp2) {
102540     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
102541     return 0;
102542   }
102543   arg2 = *argp2;
102544   arg3 = (Dali::FittingMode::Type)jarg3;
102545   {
102546     try {
102547       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3);
102548     } catch (std::out_of_range& e) {
102549       {
102550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102551       };
102552     } catch (std::exception& e) {
102553       {
102554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102555       };
102556     } catch (...) {
102557       {
102558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102559       };
102560     }
102561   }
102562   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
102563
102564   return jresult;
102565 }
102566
102567
102568 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_3(char * jarg1, void * jarg2) {
102569   void * jresult ;
102570   std::string *arg1 = 0 ;
102571   Dali::ImageDimensions arg2 ;
102572   Dali::ImageDimensions *argp2 ;
102573   Dali::Devel::PixelBuffer result;
102574
102575   if (!jarg1) {
102576     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102577     return 0;
102578   }
102579   std::string arg1_str(jarg1);
102580   arg1 = &arg1_str;
102581   argp2 = (Dali::ImageDimensions *)jarg2;
102582   if (!argp2) {
102583     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
102584     return 0;
102585   }
102586   arg2 = *argp2;
102587   {
102588     try {
102589       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2);
102590     } catch (std::out_of_range& e) {
102591       {
102592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102593       };
102594     } catch (std::exception& e) {
102595       {
102596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102597       };
102598     } catch (...) {
102599       {
102600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102601       };
102602     }
102603   }
102604   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
102605
102606   return jresult;
102607 }
102608
102609
102610 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_4(char * jarg1) {
102611   void * jresult ;
102612   std::string *arg1 = 0 ;
102613   Dali::Devel::PixelBuffer result;
102614
102615   if (!jarg1) {
102616     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102617     return 0;
102618   }
102619   std::string arg1_str(jarg1);
102620   arg1 = &arg1_str;
102621   {
102622     try {
102623       result = Dali::LoadImageFromFile((std::string const &)*arg1);
102624     } catch (std::out_of_range& e) {
102625       {
102626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102627       };
102628     } catch (std::exception& e) {
102629       {
102630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102631       };
102632     } catch (...) {
102633       {
102634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102635       };
102636     }
102637   }
102638   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
102639
102640   return jresult;
102641 }
102642
102643
102644 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
102645   void * jresult ;
102646   std::string *arg1 = 0 ;
102647   Dali::ImageDimensions arg2 ;
102648   Dali::FittingMode::Type arg3 ;
102649   Dali::SamplingMode::Type arg4 ;
102650   bool arg5 ;
102651   Dali::ImageDimensions *argp2 ;
102652   Dali::ImageDimensions result;
102653
102654   if (!jarg1) {
102655     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102656     return 0;
102657   }
102658   std::string arg1_str(jarg1);
102659   arg1 = &arg1_str;
102660   argp2 = (Dali::ImageDimensions *)jarg2;
102661   if (!argp2) {
102662     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
102663     return 0;
102664   }
102665   arg2 = *argp2;
102666   arg3 = (Dali::FittingMode::Type)jarg3;
102667   arg4 = (Dali::SamplingMode::Type)jarg4;
102668   arg5 = jarg5 ? true : false;
102669   {
102670     try {
102671       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3,arg4,arg5);
102672     } catch (std::out_of_range& e) {
102673       {
102674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102675       };
102676     } catch (std::exception& e) {
102677       {
102678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102679       };
102680     } catch (...) {
102681       {
102682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102683       };
102684     }
102685   }
102686   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
102687
102688   return jresult;
102689 }
102690
102691
102692 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
102693   void * jresult ;
102694   std::string *arg1 = 0 ;
102695   Dali::ImageDimensions arg2 ;
102696   Dali::FittingMode::Type arg3 ;
102697   Dali::SamplingMode::Type arg4 ;
102698   Dali::ImageDimensions *argp2 ;
102699   Dali::ImageDimensions result;
102700
102701   if (!jarg1) {
102702     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102703     return 0;
102704   }
102705   std::string arg1_str(jarg1);
102706   arg1 = &arg1_str;
102707   argp2 = (Dali::ImageDimensions *)jarg2;
102708   if (!argp2) {
102709     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
102710     return 0;
102711   }
102712   arg2 = *argp2;
102713   arg3 = (Dali::FittingMode::Type)jarg3;
102714   arg4 = (Dali::SamplingMode::Type)jarg4;
102715   {
102716     try {
102717       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3,arg4);
102718     } catch (std::out_of_range& e) {
102719       {
102720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102721       };
102722     } catch (std::exception& e) {
102723       {
102724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102725       };
102726     } catch (...) {
102727       {
102728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102729       };
102730     }
102731   }
102732   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
102733
102734   return jresult;
102735 }
102736
102737
102738 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
102739   void * jresult ;
102740   std::string *arg1 = 0 ;
102741   Dali::ImageDimensions arg2 ;
102742   Dali::FittingMode::Type arg3 ;
102743   Dali::ImageDimensions *argp2 ;
102744   Dali::ImageDimensions result;
102745
102746   if (!jarg1) {
102747     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102748     return 0;
102749   }
102750   std::string arg1_str(jarg1);
102751   arg1 = &arg1_str;
102752   argp2 = (Dali::ImageDimensions *)jarg2;
102753   if (!argp2) {
102754     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
102755     return 0;
102756   }
102757   arg2 = *argp2;
102758   arg3 = (Dali::FittingMode::Type)jarg3;
102759   {
102760     try {
102761       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3);
102762     } catch (std::out_of_range& e) {
102763       {
102764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102765       };
102766     } catch (std::exception& e) {
102767       {
102768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102769       };
102770     } catch (...) {
102771       {
102772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102773       };
102774     }
102775   }
102776   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
102777
102778   return jresult;
102779 }
102780
102781
102782 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_3(char * jarg1, void * jarg2) {
102783   void * jresult ;
102784   std::string *arg1 = 0 ;
102785   Dali::ImageDimensions arg2 ;
102786   Dali::ImageDimensions *argp2 ;
102787   Dali::ImageDimensions result;
102788
102789   if (!jarg1) {
102790     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102791     return 0;
102792   }
102793   std::string arg1_str(jarg1);
102794   arg1 = &arg1_str;
102795   argp2 = (Dali::ImageDimensions *)jarg2;
102796   if (!argp2) {
102797     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
102798     return 0;
102799   }
102800   arg2 = *argp2;
102801   {
102802     try {
102803       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2);
102804     } catch (std::out_of_range& e) {
102805       {
102806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102807       };
102808     } catch (std::exception& e) {
102809       {
102810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102811       };
102812     } catch (...) {
102813       {
102814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102815       };
102816     }
102817   }
102818   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
102819
102820   return jresult;
102821 }
102822
102823
102824 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_4(char * jarg1) {
102825   void * jresult ;
102826   std::string *arg1 = 0 ;
102827   Dali::ImageDimensions result;
102828
102829   if (!jarg1) {
102830     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102831     return 0;
102832   }
102833   std::string arg1_str(jarg1);
102834   arg1 = &arg1_str;
102835   {
102836     try {
102837       result = Dali::GetClosestImageSize((std::string const &)*arg1);
102838     } catch (std::out_of_range& e) {
102839       {
102840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102841       };
102842     } catch (std::exception& e) {
102843       {
102844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102845       };
102846     } catch (...) {
102847       {
102848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102849       };
102850     }
102851   }
102852   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
102853
102854   return jresult;
102855 }
102856
102857 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetOriginalImageSize(char * jarg1) {
102858   void * jresult ;
102859   std::string *arg1 = 0 ;
102860   Dali::ImageDimensions result;
102861
102862   if (!jarg1) {
102863     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102864     return 0;
102865   }
102866   std::string arg1_str(jarg1);
102867   arg1 = &arg1_str;
102868   {
102869     try {
102870       result = Dali::GetOriginalImageSize((std::string const &)*arg1);
102871     } catch (std::out_of_range& e) {
102872       {
102873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102874       };
102875     } catch (std::exception& e) {
102876       {
102877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102878       };
102879     } catch (...) {
102880       {
102881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102882       };
102883     }
102884   }
102885   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
102886
102887   return jresult;
102888 }
102889
102890 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
102891   void * jresult ;
102892   std::string *arg1 = 0 ;
102893   Dali::ImageDimensions arg2 ;
102894   Dali::FittingMode::Type arg3 ;
102895   Dali::SamplingMode::Type arg4 ;
102896   bool arg5 ;
102897   Dali::ImageDimensions *argp2 ;
102898   Dali::Devel::PixelBuffer result;
102899
102900   if (!jarg1) {
102901     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102902     return 0;
102903   }
102904   std::string arg1_str(jarg1);
102905   arg1 = &arg1_str;
102906   argp2 = (Dali::ImageDimensions *)jarg2;
102907   if (!argp2) {
102908     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
102909     return 0;
102910   }
102911   arg2 = *argp2;
102912   arg3 = (Dali::FittingMode::Type)jarg3;
102913   arg4 = (Dali::SamplingMode::Type)jarg4;
102914   arg5 = jarg5 ? true : false;
102915   {
102916     try {
102917       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3,arg4,arg5);
102918     } catch (std::out_of_range& e) {
102919       {
102920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102921       };
102922     } catch (std::exception& e) {
102923       {
102924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102925       };
102926     } catch (...) {
102927       {
102928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102929       };
102930     }
102931   }
102932   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
102933
102934   return jresult;
102935 }
102936
102937
102938 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
102939   void * jresult ;
102940   std::string *arg1 = 0 ;
102941   Dali::ImageDimensions arg2 ;
102942   Dali::FittingMode::Type arg3 ;
102943   Dali::SamplingMode::Type arg4 ;
102944   Dali::ImageDimensions *argp2 ;
102945   Dali::Devel::PixelBuffer result;
102946
102947   if (!jarg1) {
102948     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102949     return 0;
102950   }
102951   std::string arg1_str(jarg1);
102952   arg1 = &arg1_str;
102953   argp2 = (Dali::ImageDimensions *)jarg2;
102954   if (!argp2) {
102955     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
102956     return 0;
102957   }
102958   arg2 = *argp2;
102959   arg3 = (Dali::FittingMode::Type)jarg3;
102960   arg4 = (Dali::SamplingMode::Type)jarg4;
102961   {
102962     try {
102963       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3,arg4);
102964     } catch (std::out_of_range& e) {
102965       {
102966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102967       };
102968     } catch (std::exception& e) {
102969       {
102970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102971       };
102972     } catch (...) {
102973       {
102974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102975       };
102976     }
102977   }
102978   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
102979
102980   return jresult;
102981 }
102982
102983
102984 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
102985   void * jresult ;
102986   std::string *arg1 = 0 ;
102987   Dali::ImageDimensions arg2 ;
102988   Dali::FittingMode::Type arg3 ;
102989   Dali::ImageDimensions *argp2 ;
102990   Dali::Devel::PixelBuffer result;
102991
102992   if (!jarg1) {
102993     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102994     return 0;
102995   }
102996   std::string arg1_str(jarg1);
102997   arg1 = &arg1_str;
102998   argp2 = (Dali::ImageDimensions *)jarg2;
102999   if (!argp2) {
103000     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103001     return 0;
103002   }
103003   arg2 = *argp2;
103004   arg3 = (Dali::FittingMode::Type)jarg3;
103005   {
103006     try {
103007       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3);
103008     } catch (std::out_of_range& e) {
103009       {
103010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103011       };
103012     } catch (std::exception& e) {
103013       {
103014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103015       };
103016     } catch (...) {
103017       {
103018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103019       };
103020     }
103021   }
103022   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
103023
103024   return jresult;
103025 }
103026
103027
103028 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_3(char * jarg1, void * jarg2) {
103029   void * jresult ;
103030   std::string *arg1 = 0 ;
103031   Dali::ImageDimensions arg2 ;
103032   Dali::ImageDimensions *argp2 ;
103033   Dali::Devel::PixelBuffer result;
103034
103035   if (!jarg1) {
103036     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103037     return 0;
103038   }
103039   std::string arg1_str(jarg1);
103040   arg1 = &arg1_str;
103041   argp2 = (Dali::ImageDimensions *)jarg2;
103042   if (!argp2) {
103043     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103044     return 0;
103045   }
103046   arg2 = *argp2;
103047   {
103048     try {
103049       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2);
103050     } catch (std::out_of_range& e) {
103051       {
103052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103053       };
103054     } catch (std::exception& e) {
103055       {
103056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103057       };
103058     } catch (...) {
103059       {
103060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103061       };
103062     }
103063   }
103064   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
103065
103066   return jresult;
103067 }
103068
103069
103070 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_4(char * jarg1) {
103071   void * jresult ;
103072   std::string *arg1 = 0 ;
103073   Dali::Devel::PixelBuffer result;
103074
103075   if (!jarg1) {
103076     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103077     return 0;
103078   }
103079   std::string arg1_str(jarg1);
103080   arg1 = &arg1_str;
103081   {
103082     try {
103083       result = Dali::DownloadImageSynchronously((std::string const &)*arg1);
103084     } catch (std::out_of_range& e) {
103085       {
103086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103087       };
103088     } catch (std::exception& e) {
103089       {
103090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103091       };
103092     } catch (...) {
103093       {
103094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103095       };
103096     }
103097   }
103098   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
103099
103100   return jresult;
103101 }
103102
103103
103104 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_New() {
103105   void * jresult ;
103106   Dali::Toolkit::WebView result;
103107
103108   {
103109     try {
103110       result = Dali::Toolkit::WebView::New();
103111     } catch (std::out_of_range& e) {
103112       {
103113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103114       };
103115     } catch (std::exception& e) {
103116       {
103117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103118       };
103119     } catch (Dali::DaliException e) {
103120       {
103121         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
103122       };
103123     } catch (...) {
103124       {
103125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103126       };
103127     }
103128   }
103129   jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView &)result);
103130   return jresult;
103131 }
103132
103133 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_New_2(char * jarg1, char * jarg2) {
103134   void * jresult ;
103135   Dali::Toolkit::WebView result;
103136
103137   std::string *arg1;
103138   std::string *arg2;
103139
103140   if (!jarg1) {
103141     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "jarg1 is null string", 0);
103142     return 0;
103143   }
103144   if (!jarg2) {
103145     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "jarg2 is null string", 0);
103146     return 0;
103147   }
103148
103149   std::string jarg1_str = std::string(jarg1);
103150   std::string jarg2_str = std::string(jarg2);
103151
103152   arg1 = &jarg1_str;
103153   arg2 = &jarg2_str;
103154
103155   {
103156     try {
103157       result = Dali::Toolkit::WebView::New( (std::string const &)*arg1, (std::string const &)*arg2);
103158     } catch (std::out_of_range& e) {
103159       {
103160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103161       };
103162     } catch (std::exception& e) {
103163       {
103164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103165       };
103166     } catch (Dali::DaliException e) {
103167       {
103168         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
103169       };
103170     } catch (...) {
103171       {
103172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103173       };
103174     }
103175   }
103176   jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView &)result);
103177   return jresult;
103178 }
103179
103180 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebView__SWIG_1(void * jarg1) {
103181   void * jresult ;
103182   Dali::Toolkit::WebView *arg1 = 0 ;
103183   Dali::Toolkit::WebView *result = 0 ;
103184
103185   arg1 = (Dali::Toolkit::WebView *)jarg1;
103186   if (!arg1) {
103187     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::WebView const & type is null", 0);
103188     return 0;
103189   }
103190   {
103191     try {
103192       result = (Dali::Toolkit::WebView *)new Dali::Toolkit::WebView((Dali::Toolkit::WebView const &)*arg1);
103193     } catch (std::out_of_range& e) {
103194       {
103195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103196       };
103197     } catch (std::exception& e) {
103198       {
103199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103200       };
103201     } catch (Dali::DaliException e) {
103202       {
103203         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
103204       };
103205     } catch (...) {
103206       {
103207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103208       };
103209     }
103210   }
103211   jresult = (void *)result;
103212   return jresult;
103213 }
103214
103215 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebView(void * jarg1) {
103216   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103217   arg1 = (Dali::Toolkit::WebView *)jarg1;
103218   {
103219     try {
103220       delete arg1;
103221     } catch (std::out_of_range& e) {
103222       {
103223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103224       };
103225     } catch (std::exception& e) {
103226       {
103227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103228       };
103229     } catch (Dali::DaliException e) {
103230       {
103231         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103232       };
103233     } catch (...) {
103234       {
103235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103236       };
103237     }
103238   }
103239 }
103240
103241 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_Assign(void * jarg1, void * jarg2) {
103242   void * jresult ;
103243   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103244   Dali::Toolkit::WebView *arg2 = 0 ;
103245   Dali::Toolkit::WebView *result = 0 ;
103246
103247   arg1 = (Dali::Toolkit::WebView *)jarg1;
103248   arg2 = (Dali::Toolkit::WebView *)jarg2;
103249   if (!arg2) {
103250     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::WebView const & type is null", 0);
103251     return 0;
103252   }
103253   {
103254     try {
103255       result = (Dali::Toolkit::WebView *) &(arg1)->operator =((Dali::Toolkit::WebView const &)*arg2);
103256     } catch (std::out_of_range& e) {
103257       {
103258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103259       };
103260     } catch (std::exception& e) {
103261       {
103262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103263       };
103264     } catch (Dali::DaliException e) {
103265       {
103266         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
103267       };
103268     } catch (...) {
103269       {
103270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103271       };
103272     }
103273   }
103274   jresult = (void *)result;
103275   return jresult;
103276 }
103277
103278 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_DownCast(void * jarg1) {
103279   void * jresult ;
103280   Dali::BaseHandle arg1 ;
103281   Dali::BaseHandle *argp1 ;
103282   Dali::Toolkit::WebView result;
103283
103284   argp1 = (Dali::BaseHandle *)jarg1;
103285   if (!argp1) {
103286     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
103287     return 0;
103288   }
103289   arg1 = *argp1;
103290   {
103291     try {
103292       result = Dali::Toolkit::WebView::DownCast(arg1);
103293     } catch (std::out_of_range& e) {
103294       {
103295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103296       };
103297     } catch (std::exception& e) {
103298       {
103299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103300       };
103301     } catch (Dali::DaliException e) {
103302       {
103303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
103304       };
103305     } catch (...) {
103306       {
103307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103308       };
103309     }
103310   }
103311   jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView &)result);
103312   return jresult;
103313 }
103314
103315 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_LoadUrl(void * jarg1, char * jarg2) {
103316   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103317   std::string *arg2;
103318
103319   arg1 = (Dali::Toolkit::WebView *)jarg1;
103320
103321   if (!jarg2) {
103322     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103323     return;
103324   }
103325
103326   std::string jarg2str = std::string(jarg2);
103327   arg2 = &jarg2str;
103328   {
103329     try {
103330       (arg1)->LoadUrl((std::string const &)*arg2);
103331     } catch (std::out_of_range& e) {
103332       {
103333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103334       };
103335     } catch (std::exception& e) {
103336       {
103337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103338       };
103339     } catch (Dali::DaliException e) {
103340       {
103341         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103342       };
103343     } catch (...) {
103344       {
103345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103346       };
103347     }
103348   }
103349 }
103350
103351 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_WebView_GetUrl(void * jarg1) {
103352   char * jresult ;
103353   std::string result;
103354
103355   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103356
103357   arg1 = (Dali::Toolkit::WebView *)jarg1;
103358   {
103359     try {
103360       result = arg1->GetUrl();
103361     } catch (std::out_of_range& e) {
103362       {
103363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103364       };
103365     } catch (std::exception& e) {
103366       {
103367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103368       };
103369     } catch (Dali::DaliException e) {
103370       {
103371         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
103372       };
103373     } catch (...) {
103374       {
103375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103376       };
103377     }
103378   }
103379
103380   jresult = SWIG_csharp_string_callback((&result)->c_str());
103381   return jresult;
103382 }
103383
103384 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_LoadHTMLString(void * jarg1, char * jarg2) {
103385   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103386   std::string *arg2;
103387
103388   arg1 = (Dali::Toolkit::WebView *)jarg1;
103389   if (!jarg2) {
103390     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103391     return;
103392   }
103393   std::string jarg2str = std::string(jarg2);
103394   arg2 = &jarg2str;
103395   {
103396     try {
103397       (arg1)->LoadHTMLString((std::string const &)*arg2);
103398     } catch (std::out_of_range& e) {
103399       {
103400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103401       };
103402     } catch (std::exception& e) {
103403       {
103404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103405       };
103406     } catch (Dali::DaliException e) {
103407       {
103408         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103409       };
103410     } catch (...) {
103411       {
103412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103413       };
103414     }
103415   }
103416 }
103417
103418 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_Reload(void * jarg1) {
103419   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103420
103421   arg1 = (Dali::Toolkit::WebView *)jarg1;
103422   {
103423     try {
103424       (arg1)->Reload();
103425     } catch (std::out_of_range& e) {
103426       {
103427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103428       };
103429     } catch (std::exception& e) {
103430       {
103431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103432       };
103433     } catch (Dali::DaliException e) {
103434       {
103435         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103436       };
103437     } catch (...) {
103438       {
103439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103440       };
103441     }
103442   }
103443 }
103444
103445 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_StopLoading(void * jarg1) {
103446   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103447
103448   arg1 = (Dali::Toolkit::WebView *)jarg1;
103449   {
103450     try {
103451       (arg1)->StopLoading();
103452     } catch (std::out_of_range& e) {
103453       {
103454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103455       };
103456     } catch (std::exception& e) {
103457       {
103458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103459       };
103460     } catch (Dali::DaliException e) {
103461       {
103462         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103463       };
103464     } catch (...) {
103465       {
103466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103467       };
103468     }
103469   }
103470 }
103471
103472 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_GoBack(void * jarg1) {
103473   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103474
103475   arg1 = (Dali::Toolkit::WebView *)jarg1;
103476   {
103477     try {
103478       (arg1)->GoBack();
103479     } catch (std::out_of_range& e) {
103480       {
103481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103482       };
103483     } catch (std::exception& e) {
103484       {
103485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103486       };
103487     } catch (Dali::DaliException e) {
103488       {
103489         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103490       };
103491     } catch (...) {
103492       {
103493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103494       };
103495     }
103496   }
103497 }
103498
103499 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_GoForward(void * jarg1) {
103500   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103501
103502   arg1 = (Dali::Toolkit::WebView *)jarg1;
103503   {
103504     try {
103505       (arg1)->GoForward();
103506     } catch (std::out_of_range& e) {
103507       {
103508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103509       };
103510     } catch (std::exception& e) {
103511       {
103512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103513       };
103514     } catch (Dali::DaliException e) {
103515       {
103516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103517       };
103518     } catch (...) {
103519       {
103520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103521       };
103522     }
103523   }
103524 }
103525
103526 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebView_CanGoBack(void * jarg1) {
103527   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103528   bool ret;
103529
103530   arg1 = (Dali::Toolkit::WebView *)jarg1;
103531   {
103532     try {
103533       ret = (arg1)->CanGoBack();
103534     } catch (std::out_of_range& e) {
103535       {
103536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return false;
103537       };
103538     } catch (std::exception& e) {
103539       {
103540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return false;
103541       };
103542     } catch (Dali::DaliException e) {
103543       {
103544         SWIG_CSharpException(SWIG_UnknownError, e.condition); return false;
103545       };
103546     } catch (...) {
103547       {
103548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return false;
103549       };
103550     }
103551   }
103552   return ret;
103553 }
103554
103555 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebView_CanGoForward(void * jarg1) {
103556   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103557   bool ret;
103558
103559   arg1 = (Dali::Toolkit::WebView *)jarg1;
103560   {
103561     try {
103562       ret = (arg1)->CanGoForward();
103563     } catch (std::out_of_range& e) {
103564       {
103565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return false;
103566       };
103567     } catch (std::exception& e) {
103568       {
103569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return false;
103570       };
103571     } catch (Dali::DaliException e) {
103572       {
103573         SWIG_CSharpException(SWIG_UnknownError, e.condition); return false;
103574       };
103575     } catch (...) {
103576       {
103577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return false;
103578       };
103579     }
103580   }
103581   return ret;
103582 }
103583
103584 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_EvaluateJavaScript(void * jarg1, char * jarg2) {
103585   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103586   std::string *arg2;
103587
103588   arg1 = (Dali::Toolkit::WebView *)jarg1;
103589   if (!jarg2) {
103590     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103591     return;
103592   }
103593   std::string jarg2_str = std::string(jarg2);
103594   arg2 = &jarg2_str;
103595   {
103596     try {
103597       (arg1)->EvaluateJavaScript((std::string const &)*arg2);
103598     } catch (std::out_of_range& e) {
103599       {
103600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103601       };
103602     } catch (std::exception& e) {
103603       {
103604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103605       };
103606     } catch (Dali::DaliException e) {
103607       {
103608         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103609       };
103610     } catch (...) {
103611       {
103612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103613       };
103614     }
103615   }
103616 }
103617
103618 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_AddJavaScriptMessageHandler(void* jarg1, char* jarg2, void* jarg3)
103619 {
103620   if (!jarg2) {
103621     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103622     return;
103623   }
103624
103625   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
103626   std::string exposedObjectName = jarg2;
103627   void (*handler)(char*) = (void (*)(char*)) jarg3;
103628
103629   {
103630     try {
103631       webview->AddJavaScriptMessageHandler(exposedObjectName, [handler](const std::string& message) {
103632         handler(SWIG_csharp_string_callback(message.c_str()));
103633       });
103634     } catch (std::out_of_range& e) {
103635       {
103636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103637       };
103638     } catch (std::exception& e) {
103639       {
103640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103641       };
103642     } catch (Dali::DaliException e) {
103643       {
103644         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103645       };
103646     } catch (...) {
103647       {
103648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103649       };
103650     }
103651   }
103652 }
103653
103654 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ClearHistory(void * jarg1) {
103655   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103656
103657   arg1 = (Dali::Toolkit::WebView *)jarg1;
103658   {
103659     try {
103660       (arg1)->ClearHistory();
103661     } catch (std::out_of_range& e) {
103662       {
103663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103664       };
103665     } catch (std::exception& e) {
103666       {
103667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103668       };
103669     } catch (Dali::DaliException e) {
103670       {
103671         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103672       };
103673     } catch (...) {
103674       {
103675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103676       };
103677     }
103678   }
103679 }
103680
103681 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ClearCache(void * jarg1) {
103682   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103683
103684   arg1 = (Dali::Toolkit::WebView *)jarg1;
103685   {
103686     try {
103687       (arg1)->ClearCache();
103688     } catch (std::out_of_range& e) {
103689       {
103690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103691       };
103692     } catch (std::exception& e) {
103693       {
103694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103695       };
103696     } catch (Dali::DaliException e) {
103697       {
103698         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103699       };
103700     } catch (...) {
103701       {
103702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103703       };
103704     }
103705   }
103706 }
103707
103708 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_WebView_SWIGUpcast(Dali::Toolkit::WebView *jarg1) {
103709     return (Dali::Toolkit::Control *)jarg1;
103710 }
103711
103712
103713 // Proxy class of WebViewSignal.
103714 // WebViewSignal has an argument of std::string type which is not supported at C# side.
103715 // The purpose of this class is to convert signal argument of string type safely.
103716 class WebViewSignalProxy : public ConnectionTracker
103717 {
103718 public:
103719   typedef Dali::Signal< void(Dali::Toolkit::WebView, const std::string&) > OriginalSignalType;
103720   typedef Dali::Signal< void(Dali::Toolkit::WebView, char*) > ProxySignalType;
103721   typedef void (*CallbackType)(Dali::Toolkit::WebView, char *);
103722
103723   WebViewSignalProxy(OriginalSignalType* signal)
103724     : mSignalPtr(signal)
103725   {
103726   }
103727
103728   void Connect(CallbackType csharpCallback)
103729   {
103730     if (mSignalPtr->Empty())
103731     {
103732       mSignalPtr->Connect(this, &WebViewSignalProxy::OnEmit);
103733     }
103734     mProxySignal.Connect(csharpCallback);
103735   }
103736
103737   void Disconnect(CallbackType csharpCallback)
103738   {
103739     mProxySignal.Disconnect(csharpCallback);
103740     if (mProxySignal.Empty())
103741     {
103742       mSignalPtr->Disconnect(this, &WebViewSignalProxy::OnEmit);
103743     }
103744   }
103745
103746   bool Empty()
103747   {
103748     return mProxySignal.Empty();
103749   }
103750
103751   std::size_t GetConnectionCount()
103752   {
103753     return mProxySignal.GetConnectionCount();
103754   }
103755
103756   void Emit(Dali::Toolkit::WebView& webview, char* url)
103757   {
103758     if (!mProxySignal.Empty())
103759     {
103760       mProxySignal.Emit(webview, url);
103761     }
103762   }
103763
103764   void OnEmit(Dali::Toolkit::WebView webview, const std::string& url)
103765   {
103766     // Safe string conversion
103767     mProxySignal.Emit(webview, SWIG_csharp_string_callback(url.c_str()));
103768   }
103769
103770 private:
103771   OriginalSignalType* mSignalPtr;
103772   ProxySignalType mProxySignal;
103773 };
103774
103775 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebViewSignalProxy_PageLoadStarted(void * jarg1) {
103776   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
103777   WebViewSignalProxy* result = NULL;
103778   {
103779     try {
103780       result = new WebViewSignalProxy(&webview->PageLoadStartedSignal());
103781     } catch (std::out_of_range& e) {
103782       {
103783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103784       };
103785     } catch (std::exception& e) {
103786       {
103787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103788       };
103789     } catch (Dali::DaliException e) {
103790       {
103791         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
103792       };
103793     } catch (...) {
103794       {
103795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103796       };
103797     }
103798   }
103799   return (void*) result;
103800 }
103801
103802 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebViewSignalProxy_PageLoadFinished(void * jarg1) {
103803   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
103804   WebViewSignalProxy* result = NULL;
103805   {
103806     try {
103807       result = new WebViewSignalProxy(&webview->PageLoadFinishedSignal());
103808     } catch (std::out_of_range& e) {
103809       {
103810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103811       };
103812     } catch (std::exception& e) {
103813       {
103814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103815       };
103816     } catch (Dali::DaliException e) {
103817       {
103818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
103819       };
103820     } catch (...) {
103821       {
103822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103823       };
103824     }
103825   }
103826   return (void*) result;
103827 }
103828
103829 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebViewSignalProxy(void * jarg1)
103830 {
103831   WebViewSignalProxy* object = (WebViewSignalProxy*) jarg1;
103832   {
103833     try {
103834       delete object;
103835     } catch (std::out_of_range& e) {
103836       {
103837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103838       };
103839     } catch (std::exception& e) {
103840       {
103841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103842       };
103843     } catch (Dali::DaliException e) {
103844       {
103845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103846       };
103847     } catch (...) {
103848       {
103849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103850       };
103851     }
103852   }
103853 }
103854
103855 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_WebViewSignalProxy_Empty(void * jarg1)
103856 {
103857   bool result;
103858   WebViewSignalProxy* proxy = (WebViewSignalProxy*) jarg1;
103859   {
103860     try {
103861       result = (bool)proxy->Empty();
103862     } catch (std::out_of_range& e) {
103863       {
103864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103865       };
103866     } catch (std::exception& e) {
103867       {
103868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103869       };
103870     } catch (Dali::DaliException e) {
103871       {
103872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
103873       };
103874     } catch (...) {
103875       {
103876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103877       };
103878     }
103879   }
103880   return (unsigned int) result;
103881 }
103882
103883
103884 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_WebViewSignalProxy_GetConnectionCount(void * jarg1)
103885 {
103886   std::size_t result;
103887   WebViewSignalProxy* arg1 = (WebViewSignalProxy*) jarg1;
103888   {
103889     try {
103890       result = arg1->GetConnectionCount();
103891     } catch (std::out_of_range& e) {
103892       {
103893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103894       };
103895     } catch (std::exception& e) {
103896       {
103897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103898       };
103899     } catch (Dali::DaliException e) {
103900       {
103901         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
103902       };
103903     } catch (...) {
103904       {
103905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103906       };
103907     }
103908   }
103909   return (unsigned long) result;
103910 }
103911
103912 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewSignalProxy_Connect(void * jarg1, void * jarg2)
103913 {
103914   WebViewSignalProxy* proxy = (WebViewSignalProxy*) jarg1;
103915   WebViewSignalProxy::CallbackType callback = (WebViewSignalProxy::CallbackType) jarg2;
103916   {
103917     try {
103918       proxy->Connect(callback);
103919     } catch (std::out_of_range& e) {
103920       {
103921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103922       };
103923     } catch (std::exception& e) {
103924       {
103925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103926       };
103927     } catch (Dali::DaliException e) {
103928       {
103929         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103930       };
103931     } catch (...) {
103932       {
103933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103934       };
103935     }
103936   }
103937 }
103938
103939
103940 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewSignalProxy_Disconnect(void * jarg1, void * jarg2) {
103941   WebViewSignalProxy* proxy = (WebViewSignalProxy*) jarg1;
103942   WebViewSignalProxy::CallbackType callback = (WebViewSignalProxy::CallbackType) jarg2;
103943   {
103944     try {
103945       proxy->Disconnect(callback);
103946     } catch (std::out_of_range& e) {
103947       {
103948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103949       };
103950     } catch (std::exception& e) {
103951       {
103952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103953       };
103954     } catch (Dali::DaliException e) {
103955       {
103956         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103957       };
103958     } catch (...) {
103959       {
103960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103961       };
103962     }
103963   }
103964 }
103965
103966
103967 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewSignalProxy_Emit(void * jarg1, void * jarg2, char * jarg3) {
103968   if (!jarg2) {
103969     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::WebView & type is null", 0);
103970     return ;
103971   }
103972   if (!jarg3) {
103973     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "jarg3 is null string", 0);
103974     return ;
103975   }
103976
103977   WebViewSignalProxy* proxy = (WebViewSignalProxy*) jarg1;
103978   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView*) jarg2;
103979   {
103980     try {
103981       proxy->Emit(*webview, jarg3);
103982     } catch (std::out_of_range& e) {
103983       {
103984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103985       };
103986     } catch (std::exception& e) {
103987       {
103988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103989       };
103990     } catch (Dali::DaliException e) {
103991       {
103992         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103993       };
103994     } catch (...) {
103995       {
103996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103997       };
103998     }
103999   }
104000 }
104001
104002 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetEnvironmentVariable(char * jarg1) {
104003   const char * result = EnvironmentVariable::GetEnvironmentVariable(jarg1);
104004   char * jresult = SWIG_csharp_string_callback((const char *)result);
104005   return jresult;
104006 }
104007
104008 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_SetEnvironmentVariable(char * jarg1, char * jarg2) {
104009   bool result = EnvironmentVariable::SetEnvironmentVariable(jarg1, jarg2);
104010   return result;
104011 }
104012
104013 #ifdef __cplusplus
104014 }
104015 #endif
104016