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       if(parent)
36663       {
36664         const std::string parentName = parent.GetName();
36665         if(parentName.compare("rootAbsoluteLayout") == 0)
36666         {
36667           result -= 1;
36668         }
36669       }
36670     } catch (std::out_of_range& e) {
36671       {
36672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36673       };
36674     } catch (std::exception& e) {
36675       {
36676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36677       };
36678     } catch (Dali::DaliException e) {
36679       {
36680         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36681       };
36682     } catch (...) {
36683       {
36684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36685       };
36686     }
36687   }
36688
36689   jresult = result;
36690   return jresult;
36691 }
36692
36693
36694 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_AddRenderer(void * jarg1, void * jarg2) {
36695   unsigned int jresult ;
36696   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36697   Dali::Renderer *arg2 = 0 ;
36698   unsigned int result;
36699
36700   arg1 = (Dali::Actor *)jarg1;
36701   arg2 = (Dali::Renderer *)jarg2;
36702   if (!arg2) {
36703     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
36704     return 0;
36705   }
36706   {
36707     try {
36708       result = (unsigned int)(arg1)->AddRenderer(*arg2);
36709     } catch (std::out_of_range& e) {
36710       {
36711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36712       };
36713     } catch (std::exception& e) {
36714       {
36715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36716       };
36717     } catch (Dali::DaliException e) {
36718       {
36719         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36720       };
36721     } catch (...) {
36722       {
36723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36724       };
36725     }
36726   }
36727
36728   jresult = result;
36729   return jresult;
36730 }
36731
36732
36733 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetRendererCount(void * jarg1) {
36734   unsigned int jresult ;
36735   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36736   unsigned int result;
36737
36738   arg1 = (Dali::Actor *)jarg1;
36739   {
36740     try {
36741       result = (unsigned int)((Dali::Actor const *)arg1)->GetRendererCount();
36742     } catch (std::out_of_range& e) {
36743       {
36744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36745       };
36746     } catch (std::exception& e) {
36747       {
36748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36749       };
36750     } catch (Dali::DaliException e) {
36751       {
36752         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36753       };
36754     } catch (...) {
36755       {
36756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36757       };
36758     }
36759   }
36760
36761   jresult = result;
36762   return jresult;
36763 }
36764
36765
36766 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetRendererAt(void * jarg1, unsigned int jarg2) {
36767   void * jresult ;
36768   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36769   unsigned int arg2 ;
36770   Dali::Renderer result;
36771
36772   arg1 = (Dali::Actor *)jarg1;
36773   arg2 = (unsigned int)jarg2;
36774   {
36775     try {
36776       result = (arg1)->GetRendererAt(arg2);
36777     } catch (std::out_of_range& e) {
36778       {
36779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36780       };
36781     } catch (std::exception& e) {
36782       {
36783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36784       };
36785     } catch (Dali::DaliException e) {
36786       {
36787         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36788       };
36789     } catch (...) {
36790       {
36791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36792       };
36793     }
36794   }
36795
36796   jresult = new Dali::Renderer((const Dali::Renderer &)result);
36797   return jresult;
36798 }
36799
36800
36801 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_0(void * jarg1, void * jarg2) {
36802   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36803   Dali::Renderer *arg2 = 0 ;
36804
36805   arg1 = (Dali::Actor *)jarg1;
36806   arg2 = (Dali::Renderer *)jarg2;
36807   if (!arg2) {
36808     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
36809     return ;
36810   }
36811   {
36812     try {
36813       (arg1)->RemoveRenderer(*arg2);
36814     } catch (std::out_of_range& e) {
36815       {
36816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36817       };
36818     } catch (std::exception& e) {
36819       {
36820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36821       };
36822     } catch (Dali::DaliException e) {
36823       {
36824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36825       };
36826     } catch (...) {
36827       {
36828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36829       };
36830     }
36831   }
36832
36833 }
36834
36835
36836 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_1(void * jarg1, unsigned int jarg2) {
36837   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36838   unsigned int arg2 ;
36839
36840   arg1 = (Dali::Actor *)jarg1;
36841   arg2 = (unsigned int)jarg2;
36842   {
36843     try {
36844       (arg1)->RemoveRenderer(arg2);
36845     } catch (std::out_of_range& e) {
36846       {
36847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36848       };
36849     } catch (std::exception& e) {
36850       {
36851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36852       };
36853     } catch (Dali::DaliException e) {
36854       {
36855         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36856       };
36857     } catch (...) {
36858       {
36859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36860       };
36861     }
36862   }
36863
36864 }
36865
36866
36867 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchedSignal(void * jarg1) {
36868   void * jresult ;
36869   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36870   Dali::Actor::TouchSignalType *result = 0 ;
36871
36872   arg1 = (Dali::Actor *)jarg1;
36873   {
36874     try {
36875       result = (Dali::Actor::TouchSignalType *) &(arg1)->TouchedSignal();
36876     } catch (std::out_of_range& e) {
36877       {
36878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36879       };
36880     } catch (std::exception& e) {
36881       {
36882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36883       };
36884     } catch (Dali::DaliException e) {
36885       {
36886         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36887       };
36888     } catch (...) {
36889       {
36890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36891       };
36892     }
36893   }
36894
36895   jresult = (void *)result;
36896   return jresult;
36897 }
36898
36899
36900 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchSignal(void * jarg1) {
36901   void * jresult ;
36902   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36903   Dali::Actor::TouchDataSignalType *result = 0 ;
36904
36905   arg1 = (Dali::Actor *)jarg1;
36906   {
36907     try {
36908       result = (Dali::Actor::TouchDataSignalType *) &(arg1)->TouchSignal();
36909     } catch (std::out_of_range& e) {
36910       {
36911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36912       };
36913     } catch (std::exception& e) {
36914       {
36915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36916       };
36917     } catch (Dali::DaliException e) {
36918       {
36919         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36920       };
36921     } catch (...) {
36922       {
36923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36924       };
36925     }
36926   }
36927
36928   jresult = (void *)result;
36929   return jresult;
36930 }
36931
36932
36933 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_HoveredSignal(void * jarg1) {
36934   void * jresult ;
36935   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36936   Dali::Actor::HoverSignalType *result = 0 ;
36937
36938   arg1 = (Dali::Actor *)jarg1;
36939   {
36940     try {
36941       result = (Dali::Actor::HoverSignalType *) &(arg1)->HoveredSignal();
36942     } catch (std::out_of_range& e) {
36943       {
36944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36945       };
36946     } catch (std::exception& e) {
36947       {
36948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36949       };
36950     } catch (Dali::DaliException e) {
36951       {
36952         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36953       };
36954     } catch (...) {
36955       {
36956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36957       };
36958     }
36959   }
36960
36961   jresult = (void *)result;
36962   return jresult;
36963 }
36964
36965
36966 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_WheelEventSignal(void * jarg1) {
36967   void * jresult ;
36968   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36969   Dali::Actor::WheelEventSignalType *result = 0 ;
36970
36971   arg1 = (Dali::Actor *)jarg1;
36972   {
36973     try {
36974       result = (Dali::Actor::WheelEventSignalType *) &(arg1)->WheelEventSignal();
36975     } catch (std::out_of_range& e) {
36976       {
36977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36978       };
36979     } catch (std::exception& e) {
36980       {
36981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36982       };
36983     } catch (Dali::DaliException e) {
36984       {
36985         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36986       };
36987     } catch (...) {
36988       {
36989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36990       };
36991     }
36992   }
36993
36994   jresult = (void *)result;
36995   return jresult;
36996 }
36997
36998
36999 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnStageSignal(void * jarg1) {
37000   void * jresult ;
37001   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37002   Dali::Actor::OnStageSignalType *result = 0 ;
37003
37004   arg1 = (Dali::Actor *)jarg1;
37005   {
37006     try {
37007       result = (Dali::Actor::OnStageSignalType *) &(arg1)->OnStageSignal();
37008     } catch (std::out_of_range& e) {
37009       {
37010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37011       };
37012     } catch (std::exception& e) {
37013       {
37014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37015       };
37016     } catch (Dali::DaliException e) {
37017       {
37018         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37019       };
37020     } catch (...) {
37021       {
37022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37023       };
37024     }
37025   }
37026
37027   jresult = (void *)result;
37028   return jresult;
37029 }
37030
37031
37032 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OffStageSignal(void * jarg1) {
37033   void * jresult ;
37034   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37035   Dali::Actor::OffStageSignalType *result = 0 ;
37036
37037   arg1 = (Dali::Actor *)jarg1;
37038   {
37039     try {
37040       result = (Dali::Actor::OffStageSignalType *) &(arg1)->OffStageSignal();
37041     } catch (std::out_of_range& e) {
37042       {
37043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37044       };
37045     } catch (std::exception& e) {
37046       {
37047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37048       };
37049     } catch (Dali::DaliException e) {
37050       {
37051         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37052       };
37053     } catch (...) {
37054       {
37055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37056       };
37057     }
37058   }
37059
37060   jresult = (void *)result;
37061   return jresult;
37062 }
37063
37064
37065 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnRelayoutSignal(void * jarg1) {
37066   void * jresult ;
37067   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37068   Dali::Actor::OnRelayoutSignalType *result = 0 ;
37069
37070   arg1 = (Dali::Actor *)jarg1;
37071   {
37072     try {
37073       result = (Dali::Actor::OnRelayoutSignalType *) &(arg1)->OnRelayoutSignal();
37074     } catch (std::out_of_range& e) {
37075       {
37076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37077       };
37078     } catch (std::exception& e) {
37079       {
37080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37081       };
37082     } catch (Dali::DaliException e) {
37083       {
37084         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37085       };
37086     } catch (...) {
37087       {
37088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37089       };
37090     }
37091   }
37092
37093   jresult = (void *)result;
37094   return jresult;
37095 }
37096
37097
37098 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_UnparentAndReset(void * jarg1) {
37099   Dali::Actor *arg1 = 0 ;
37100
37101   arg1 = (Dali::Actor *)jarg1;
37102   if (!arg1) {
37103     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
37104     return ;
37105   }
37106   {
37107     try {
37108       Dali::UnparentAndReset(*arg1);
37109     } catch (std::out_of_range& e) {
37110       {
37111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37112       };
37113     } catch (std::exception& e) {
37114       {
37115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37116       };
37117     } catch (Dali::DaliException e) {
37118       {
37119         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37120       };
37121     } catch (...) {
37122       {
37123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37124       };
37125     }
37126   }
37127
37128 }
37129
37130
37131 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_ENABLE_get() {
37132   int jresult ;
37133   int result;
37134
37135   result = (int)Dali::Layer::Property::CLIPPING_ENABLE;
37136   jresult = (int)result;
37137   return jresult;
37138 }
37139
37140
37141 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_BOX_get() {
37142   int jresult ;
37143   int result;
37144
37145   result = (int)Dali::Layer::Property::CLIPPING_BOX;
37146   jresult = (int)result;
37147   return jresult;
37148 }
37149
37150
37151 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_BEHAVIOR_get() {
37152   int jresult ;
37153   int result;
37154
37155   result = (int)Dali::Layer::Property::BEHAVIOR;
37156   jresult = (int)result;
37157   return jresult;
37158 }
37159
37160
37161 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer_Property() {
37162   void * jresult ;
37163   Dali::Layer::Property *result = 0 ;
37164
37165   {
37166     try {
37167       result = (Dali::Layer::Property *)new Dali::Layer::Property();
37168     } catch (std::out_of_range& e) {
37169       {
37170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37171       };
37172     } catch (std::exception& e) {
37173       {
37174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37175       };
37176     } catch (Dali::DaliException e) {
37177       {
37178         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37179       };
37180     } catch (...) {
37181       {
37182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37183       };
37184     }
37185   }
37186
37187   jresult = (void *)result;
37188   return jresult;
37189 }
37190
37191
37192 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer_Property(void * jarg1) {
37193   Dali::Layer::Property *arg1 = (Dali::Layer::Property *) 0 ;
37194
37195   arg1 = (Dali::Layer::Property *)jarg1;
37196   {
37197     try {
37198       delete arg1;
37199     } catch (std::out_of_range& e) {
37200       {
37201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37202       };
37203     } catch (std::exception& e) {
37204       {
37205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37206       };
37207     } catch (Dali::DaliException e) {
37208       {
37209         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37210       };
37211     } catch (...) {
37212       {
37213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37214       };
37215     }
37216   }
37217
37218 }
37219
37220
37221 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_0() {
37222   void * jresult ;
37223   Dali::Layer *result = 0 ;
37224
37225   {
37226     try {
37227       result = (Dali::Layer *)new Dali::Layer();
37228     } catch (std::out_of_range& e) {
37229       {
37230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37231       };
37232     } catch (std::exception& e) {
37233       {
37234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37235       };
37236     } catch (Dali::DaliException e) {
37237       {
37238         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37239       };
37240     } catch (...) {
37241       {
37242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37243       };
37244     }
37245   }
37246
37247   jresult = (void *)result;
37248   return jresult;
37249 }
37250
37251
37252 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_New() {
37253   void * jresult ;
37254   Dali::Layer result;
37255
37256   {
37257     try {
37258       result = Dali::Layer::New();
37259     } catch (std::out_of_range& e) {
37260       {
37261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37262       };
37263     } catch (std::exception& e) {
37264       {
37265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37266       };
37267     } catch (Dali::DaliException e) {
37268       {
37269         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37270       };
37271     } catch (...) {
37272       {
37273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37274       };
37275     }
37276   }
37277
37278   jresult = new Dali::Layer((const Dali::Layer &)result);
37279   return jresult;
37280 }
37281
37282
37283 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_DownCast(void * jarg1) {
37284   void * jresult ;
37285   Dali::BaseHandle arg1 ;
37286   Dali::BaseHandle *argp1 ;
37287   Dali::Layer result;
37288
37289   argp1 = (Dali::BaseHandle *)jarg1;
37290   if (!argp1) {
37291     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
37292     return 0;
37293   }
37294   arg1 = *argp1;
37295   {
37296     try {
37297       result = Dali::Layer::DownCast(arg1);
37298     } catch (std::out_of_range& e) {
37299       {
37300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37301       };
37302     } catch (std::exception& e) {
37303       {
37304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37305       };
37306     } catch (Dali::DaliException e) {
37307       {
37308         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37309       };
37310     } catch (...) {
37311       {
37312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37313       };
37314     }
37315   }
37316
37317   jresult = new Dali::Layer((const Dali::Layer &)result);
37318   return jresult;
37319 }
37320
37321
37322 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer(void * jarg1) {
37323   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37324
37325   arg1 = (Dali::Layer *)jarg1;
37326   {
37327     try {
37328       delete arg1;
37329     } catch (std::out_of_range& e) {
37330       {
37331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37332       };
37333     } catch (std::exception& e) {
37334       {
37335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37336       };
37337     } catch (Dali::DaliException e) {
37338       {
37339         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37340       };
37341     } catch (...) {
37342       {
37343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37344       };
37345     }
37346   }
37347
37348 }
37349
37350
37351 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_1(void * jarg1) {
37352   void * jresult ;
37353   Dali::Layer *arg1 = 0 ;
37354   Dali::Layer *result = 0 ;
37355
37356   arg1 = (Dali::Layer *)jarg1;
37357   if (!arg1) {
37358     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
37359     return 0;
37360   }
37361   {
37362     try {
37363       result = (Dali::Layer *)new Dali::Layer((Dali::Layer const &)*arg1);
37364     } catch (std::out_of_range& e) {
37365       {
37366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37367       };
37368     } catch (std::exception& e) {
37369       {
37370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37371       };
37372     } catch (Dali::DaliException e) {
37373       {
37374         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37375       };
37376     } catch (...) {
37377       {
37378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37379       };
37380     }
37381   }
37382
37383   jresult = (void *)result;
37384   return jresult;
37385 }
37386
37387
37388 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_Assign(void * jarg1, void * jarg2) {
37389   void * jresult ;
37390   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37391   Dali::Layer *arg2 = 0 ;
37392   Dali::Layer *result = 0 ;
37393
37394   arg1 = (Dali::Layer *)jarg1;
37395   arg2 = (Dali::Layer *)jarg2;
37396   if (!arg2) {
37397     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
37398     return 0;
37399   }
37400   {
37401     try {
37402       result = (Dali::Layer *) &(arg1)->operator =((Dali::Layer const &)*arg2);
37403     } catch (std::out_of_range& e) {
37404       {
37405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37406       };
37407     } catch (std::exception& e) {
37408       {
37409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37410       };
37411     } catch (Dali::DaliException e) {
37412       {
37413         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37414       };
37415     } catch (...) {
37416       {
37417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37418       };
37419     }
37420   }
37421
37422   jresult = (void *)result;
37423   return jresult;
37424 }
37425
37426
37427 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_GetDepth(void * jarg1) {
37428   unsigned int jresult ;
37429   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37430   unsigned int result;
37431
37432   arg1 = (Dali::Layer *)jarg1;
37433   {
37434     try {
37435       result = (unsigned int)((Dali::Layer const *)arg1)->GetDepth();
37436     } catch (std::out_of_range& e) {
37437       {
37438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37439       };
37440     } catch (std::exception& e) {
37441       {
37442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37443       };
37444     } catch (Dali::DaliException e) {
37445       {
37446         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37447       };
37448     } catch (...) {
37449       {
37450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37451       };
37452     }
37453   }
37454
37455   jresult = result;
37456   return jresult;
37457 }
37458
37459
37460 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Raise(void * jarg1) {
37461   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37462
37463   arg1 = (Dali::Layer *)jarg1;
37464   {
37465     try {
37466       (arg1)->Raise();
37467     } catch (std::out_of_range& e) {
37468       {
37469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37470       };
37471     } catch (std::exception& e) {
37472       {
37473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37474       };
37475     } catch (Dali::DaliException e) {
37476       {
37477         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37478       };
37479     } catch (...) {
37480       {
37481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37482       };
37483     }
37484   }
37485
37486 }
37487
37488
37489 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Lower(void * jarg1) {
37490   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37491
37492   arg1 = (Dali::Layer *)jarg1;
37493   {
37494     try {
37495       (arg1)->Lower();
37496     } catch (std::out_of_range& e) {
37497       {
37498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37499       };
37500     } catch (std::exception& e) {
37501       {
37502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37503       };
37504     } catch (Dali::DaliException e) {
37505       {
37506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37507       };
37508     } catch (...) {
37509       {
37510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37511       };
37512     }
37513   }
37514
37515 }
37516
37517
37518 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseAbove(void * jarg1, void * jarg2) {
37519   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37520   Dali::Layer arg2 ;
37521   Dali::Layer *argp2 ;
37522
37523   arg1 = (Dali::Layer *)jarg1;
37524   argp2 = (Dali::Layer *)jarg2;
37525   if (!argp2) {
37526     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37527     return ;
37528   }
37529   arg2 = *argp2;
37530   {
37531     try {
37532       (arg1)->RaiseAbove(arg2);
37533     } catch (std::out_of_range& e) {
37534       {
37535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37536       };
37537     } catch (std::exception& e) {
37538       {
37539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37540       };
37541     } catch (Dali::DaliException e) {
37542       {
37543         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37544       };
37545     } catch (...) {
37546       {
37547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37548       };
37549     }
37550   }
37551
37552 }
37553
37554
37555 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerBelow(void * jarg1, void * jarg2) {
37556   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37557   Dali::Layer arg2 ;
37558   Dali::Layer *argp2 ;
37559
37560   arg1 = (Dali::Layer *)jarg1;
37561   argp2 = (Dali::Layer *)jarg2;
37562   if (!argp2) {
37563     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37564     return ;
37565   }
37566   arg2 = *argp2;
37567   {
37568     try {
37569       (arg1)->LowerBelow(arg2);
37570     } catch (std::out_of_range& e) {
37571       {
37572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37573       };
37574     } catch (std::exception& e) {
37575       {
37576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37577       };
37578     } catch (Dali::DaliException e) {
37579       {
37580         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37581       };
37582     } catch (...) {
37583       {
37584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37585       };
37586     }
37587   }
37588
37589 }
37590
37591
37592 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseToTop(void * jarg1) {
37593   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37594
37595   arg1 = (Dali::Layer *)jarg1;
37596   {
37597     try {
37598       (arg1)->RaiseToTop();
37599     } catch (std::out_of_range& e) {
37600       {
37601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37602       };
37603     } catch (std::exception& e) {
37604       {
37605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37606       };
37607     } catch (Dali::DaliException e) {
37608       {
37609         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37610       };
37611     } catch (...) {
37612       {
37613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37614       };
37615     }
37616   }
37617
37618 }
37619
37620
37621 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerToBottom(void * jarg1) {
37622   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37623
37624   arg1 = (Dali::Layer *)jarg1;
37625   {
37626     try {
37627       (arg1)->LowerToBottom();
37628     } catch (std::out_of_range& e) {
37629       {
37630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37631       };
37632     } catch (std::exception& e) {
37633       {
37634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37635       };
37636     } catch (Dali::DaliException e) {
37637       {
37638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37639       };
37640     } catch (...) {
37641       {
37642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37643       };
37644     }
37645   }
37646
37647 }
37648
37649
37650 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveAbove(void * jarg1, void * jarg2) {
37651   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37652   Dali::Layer arg2 ;
37653   Dali::Layer *argp2 ;
37654
37655   arg1 = (Dali::Layer *)jarg1;
37656   argp2 = (Dali::Layer *)jarg2;
37657   if (!argp2) {
37658     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37659     return ;
37660   }
37661   arg2 = *argp2;
37662   {
37663     try {
37664       (arg1)->MoveAbove(arg2);
37665     } catch (std::out_of_range& e) {
37666       {
37667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37668       };
37669     } catch (std::exception& e) {
37670       {
37671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37672       };
37673     } catch (Dali::DaliException e) {
37674       {
37675         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37676       };
37677     } catch (...) {
37678       {
37679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37680       };
37681     }
37682   }
37683
37684 }
37685
37686
37687 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveBelow(void * jarg1, void * jarg2) {
37688   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37689   Dali::Layer arg2 ;
37690   Dali::Layer *argp2 ;
37691
37692   arg1 = (Dali::Layer *)jarg1;
37693   argp2 = (Dali::Layer *)jarg2;
37694   if (!argp2) {
37695     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37696     return ;
37697   }
37698   arg2 = *argp2;
37699   {
37700     try {
37701       (arg1)->MoveBelow(arg2);
37702     } catch (std::out_of_range& e) {
37703       {
37704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37705       };
37706     } catch (std::exception& e) {
37707       {
37708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37709       };
37710     } catch (Dali::DaliException e) {
37711       {
37712         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37713       };
37714     } catch (...) {
37715       {
37716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37717       };
37718     }
37719   }
37720
37721 }
37722
37723
37724 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetBehavior(void * jarg1, int jarg2) {
37725   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37726   Dali::Layer::Behavior arg2 ;
37727
37728   arg1 = (Dali::Layer *)jarg1;
37729   arg2 = (Dali::Layer::Behavior)jarg2;
37730   {
37731     try {
37732       (arg1)->SetBehavior(arg2);
37733     } catch (std::out_of_range& e) {
37734       {
37735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37736       };
37737     } catch (std::exception& e) {
37738       {
37739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37740       };
37741     } catch (Dali::DaliException e) {
37742       {
37743         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37744       };
37745     } catch (...) {
37746       {
37747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37748       };
37749     }
37750   }
37751
37752 }
37753
37754
37755 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_GetBehavior(void * jarg1) {
37756   int jresult ;
37757   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37758   Dali::Layer::Behavior result;
37759
37760   arg1 = (Dali::Layer *)jarg1;
37761   {
37762     try {
37763       result = (Dali::Layer::Behavior)((Dali::Layer const *)arg1)->GetBehavior();
37764     } catch (std::out_of_range& e) {
37765       {
37766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37767       };
37768     } catch (std::exception& e) {
37769       {
37770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37771       };
37772     } catch (Dali::DaliException e) {
37773       {
37774         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37775       };
37776     } catch (...) {
37777       {
37778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37779       };
37780     }
37781   }
37782
37783   jresult = (int)result;
37784   return jresult;
37785 }
37786
37787
37788 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClipping(void * jarg1, unsigned int jarg2) {
37789   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37790   bool arg2 ;
37791
37792   arg1 = (Dali::Layer *)jarg1;
37793   arg2 = jarg2 ? true : false;
37794   {
37795     try {
37796       (arg1)->SetClipping(arg2);
37797     } catch (std::out_of_range& e) {
37798       {
37799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37800       };
37801     } catch (std::exception& e) {
37802       {
37803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37804       };
37805     } catch (Dali::DaliException e) {
37806       {
37807         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37808       };
37809     } catch (...) {
37810       {
37811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37812       };
37813     }
37814   }
37815
37816 }
37817
37818
37819 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsClipping(void * jarg1) {
37820   unsigned int jresult ;
37821   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37822   bool result;
37823
37824   arg1 = (Dali::Layer *)jarg1;
37825   {
37826     try {
37827       result = (bool)((Dali::Layer const *)arg1)->IsClipping();
37828     } catch (std::out_of_range& e) {
37829       {
37830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37831       };
37832     } catch (std::exception& e) {
37833       {
37834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37835       };
37836     } catch (Dali::DaliException e) {
37837       {
37838         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37839       };
37840     } catch (...) {
37841       {
37842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37843       };
37844     }
37845   }
37846
37847   jresult = result;
37848   return jresult;
37849 }
37850
37851
37852 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_0(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
37853   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37854   int arg2 ;
37855   int arg3 ;
37856   int arg4 ;
37857   int arg5 ;
37858
37859   arg1 = (Dali::Layer *)jarg1;
37860   arg2 = (int)jarg2;
37861   arg3 = (int)jarg3;
37862   arg4 = (int)jarg4;
37863   arg5 = (int)jarg5;
37864   {
37865     try {
37866       (arg1)->SetClippingBox(arg2,arg3,arg4,arg5);
37867     } catch (std::out_of_range& e) {
37868       {
37869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37870       };
37871     } catch (std::exception& e) {
37872       {
37873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37874       };
37875     } catch (Dali::DaliException e) {
37876       {
37877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37878       };
37879     } catch (...) {
37880       {
37881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37882       };
37883     }
37884   }
37885
37886 }
37887
37888
37889 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_1(void * jarg1, void * jarg2) {
37890   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37891   Dali::ClippingBox arg2 ;
37892   Dali::ClippingBox *argp2 ;
37893
37894   arg1 = (Dali::Layer *)jarg1;
37895   argp2 = (Dali::ClippingBox *)jarg2;
37896   if (!argp2) {
37897     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ClippingBox", 0);
37898     return ;
37899   }
37900   arg2 = *argp2;
37901   {
37902     try {
37903       (arg1)->SetClippingBox(arg2);
37904     } catch (std::out_of_range& e) {
37905       {
37906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37907       };
37908     } catch (std::exception& e) {
37909       {
37910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37911       };
37912     } catch (Dali::DaliException e) {
37913       {
37914         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37915       };
37916     } catch (...) {
37917       {
37918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37919       };
37920     }
37921   }
37922
37923 }
37924
37925
37926 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_GetClippingBox(void * jarg1) {
37927   void * jresult ;
37928   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37929   Dali::ClippingBox result;
37930
37931   arg1 = (Dali::Layer *)jarg1;
37932   {
37933     try {
37934       result = ((Dali::Layer const *)arg1)->GetClippingBox();
37935     } catch (std::out_of_range& e) {
37936       {
37937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37938       };
37939     } catch (std::exception& e) {
37940       {
37941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37942       };
37943     } catch (Dali::DaliException e) {
37944       {
37945         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37946       };
37947     } catch (...) {
37948       {
37949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37950       };
37951     }
37952   }
37953
37954   jresult = new Dali::ClippingBox((const Dali::ClippingBox &)result);
37955   return jresult;
37956 }
37957
37958
37959 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetDepthTestDisabled(void * jarg1, unsigned int jarg2) {
37960   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37961   bool arg2 ;
37962
37963   arg1 = (Dali::Layer *)jarg1;
37964   arg2 = jarg2 ? true : false;
37965   {
37966     try {
37967       (arg1)->SetDepthTestDisabled(arg2);
37968     } catch (std::out_of_range& e) {
37969       {
37970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37971       };
37972     } catch (std::exception& e) {
37973       {
37974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37975       };
37976     } catch (Dali::DaliException e) {
37977       {
37978         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37979       };
37980     } catch (...) {
37981       {
37982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37983       };
37984     }
37985   }
37986
37987 }
37988
37989
37990 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsDepthTestDisabled(void * jarg1) {
37991   unsigned int jresult ;
37992   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37993   bool result;
37994
37995   arg1 = (Dali::Layer *)jarg1;
37996   {
37997     try {
37998       result = (bool)((Dali::Layer const *)arg1)->IsDepthTestDisabled();
37999     } catch (std::out_of_range& e) {
38000       {
38001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38002       };
38003     } catch (std::exception& e) {
38004       {
38005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38006       };
38007     } catch (Dali::DaliException e) {
38008       {
38009         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38010       };
38011     } catch (...) {
38012       {
38013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38014       };
38015     }
38016   }
38017
38018   jresult = result;
38019   return jresult;
38020 }
38021
38022
38023 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetSortFunction(void * jarg1, void * jarg2) {
38024   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38025   Dali::Layer::SortFunctionType arg2 = (Dali::Layer::SortFunctionType) 0 ;
38026
38027   arg1 = (Dali::Layer *)jarg1;
38028   arg2 = (Dali::Layer::SortFunctionType)jarg2;
38029   {
38030     try {
38031       (arg1)->SetSortFunction(arg2);
38032     } catch (std::out_of_range& e) {
38033       {
38034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38035       };
38036     } catch (std::exception& e) {
38037       {
38038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38039       };
38040     } catch (Dali::DaliException e) {
38041       {
38042         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38043       };
38044     } catch (...) {
38045       {
38046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38047       };
38048     }
38049   }
38050
38051 }
38052
38053
38054 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetTouchConsumed(void * jarg1, unsigned int jarg2) {
38055   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38056   bool arg2 ;
38057
38058   arg1 = (Dali::Layer *)jarg1;
38059   arg2 = jarg2 ? true : false;
38060   {
38061     try {
38062       (arg1)->SetTouchConsumed(arg2);
38063     } catch (std::out_of_range& e) {
38064       {
38065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38066       };
38067     } catch (std::exception& e) {
38068       {
38069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38070       };
38071     } catch (Dali::DaliException e) {
38072       {
38073         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38074       };
38075     } catch (...) {
38076       {
38077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38078       };
38079     }
38080   }
38081
38082 }
38083
38084
38085 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsTouchConsumed(void * jarg1) {
38086   unsigned int jresult ;
38087   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38088   bool result;
38089
38090   arg1 = (Dali::Layer *)jarg1;
38091   {
38092     try {
38093       result = (bool)((Dali::Layer const *)arg1)->IsTouchConsumed();
38094     } catch (std::out_of_range& e) {
38095       {
38096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38097       };
38098     } catch (std::exception& e) {
38099       {
38100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38101       };
38102     } catch (Dali::DaliException e) {
38103       {
38104         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38105       };
38106     } catch (...) {
38107       {
38108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38109       };
38110     }
38111   }
38112
38113   jresult = result;
38114   return jresult;
38115 }
38116
38117
38118 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetHoverConsumed(void * jarg1, unsigned int jarg2) {
38119   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38120   bool arg2 ;
38121
38122   arg1 = (Dali::Layer *)jarg1;
38123   arg2 = jarg2 ? true : false;
38124   {
38125     try {
38126       (arg1)->SetHoverConsumed(arg2);
38127     } catch (std::out_of_range& e) {
38128       {
38129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38130       };
38131     } catch (std::exception& e) {
38132       {
38133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38134       };
38135     } catch (Dali::DaliException e) {
38136       {
38137         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38138       };
38139     } catch (...) {
38140       {
38141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38142       };
38143     }
38144   }
38145
38146 }
38147
38148
38149 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsHoverConsumed(void * jarg1) {
38150   unsigned int jresult ;
38151   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38152   bool result;
38153
38154   arg1 = (Dali::Layer *)jarg1;
38155   {
38156     try {
38157       result = (bool)((Dali::Layer const *)arg1)->IsHoverConsumed();
38158     } catch (std::out_of_range& e) {
38159       {
38160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38161       };
38162     } catch (std::exception& e) {
38163       {
38164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38165       };
38166     } catch (Dali::DaliException e) {
38167       {
38168         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38169       };
38170     } catch (...) {
38171       {
38172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38173       };
38174     }
38175   }
38176
38177   jresult = result;
38178   return jresult;
38179 }
38180
38181
38182 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_DEFAULT_BACKGROUND_COLOR_get() {
38183   void * jresult ;
38184   Dali::Vector4 *result = 0 ;
38185
38186   result = (Dali::Vector4 *)&Dali::Stage::DEFAULT_BACKGROUND_COLOR;
38187   jresult = (void *)result;
38188   return jresult;
38189 }
38190
38191
38192 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_DEBUG_BACKGROUND_COLOR_get() {
38193   void * jresult ;
38194   Dali::Vector4 *result = 0 ;
38195
38196   result = (Dali::Vector4 *)&Dali::Stage::DEBUG_BACKGROUND_COLOR;
38197   jresult = (void *)result;
38198   return jresult;
38199 }
38200
38201
38202 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Stage__SWIG_0() {
38203   void * jresult ;
38204   Dali::Stage *result = 0 ;
38205
38206   {
38207     try {
38208       result = (Dali::Stage *)new Dali::Stage();
38209     } catch (std::out_of_range& e) {
38210       {
38211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38212       };
38213     } catch (std::exception& e) {
38214       {
38215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38216       };
38217     } catch (Dali::DaliException e) {
38218       {
38219         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38220       };
38221     } catch (...) {
38222       {
38223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38224       };
38225     }
38226   }
38227
38228   jresult = (void *)result;
38229   return jresult;
38230 }
38231
38232
38233 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetCurrent() {
38234   void * jresult ;
38235   Dali::Stage result;
38236
38237   {
38238     try {
38239       result = Dali::Stage::GetCurrent();
38240     } catch (std::out_of_range& e) {
38241       {
38242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38243       };
38244     } catch (std::exception& e) {
38245       {
38246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38247       };
38248     } catch (Dali::DaliException e) {
38249       {
38250         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38251       };
38252     } catch (...) {
38253       {
38254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38255       };
38256     }
38257   }
38258
38259   jresult = new Dali::Stage((const Dali::Stage &)result);
38260   return jresult;
38261 }
38262
38263
38264 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_IsInstalled() {
38265   unsigned int jresult ;
38266   bool result;
38267
38268   {
38269     try {
38270       result = (bool)Dali::Stage::IsInstalled();
38271     } catch (std::out_of_range& e) {
38272       {
38273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38274       };
38275     } catch (std::exception& e) {
38276       {
38277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38278       };
38279     } catch (Dali::DaliException e) {
38280       {
38281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38282       };
38283     } catch (...) {
38284       {
38285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38286       };
38287     }
38288   }
38289
38290   jresult = result;
38291   return jresult;
38292 }
38293
38294
38295 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Stage(void * jarg1) {
38296   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38297
38298   arg1 = (Dali::Stage *)jarg1;
38299   {
38300     try {
38301       delete arg1;
38302     } catch (std::out_of_range& e) {
38303       {
38304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38305       };
38306     } catch (std::exception& e) {
38307       {
38308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38309       };
38310     } catch (Dali::DaliException e) {
38311       {
38312         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38313       };
38314     } catch (...) {
38315       {
38316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38317       };
38318     }
38319   }
38320
38321 }
38322
38323
38324 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Stage__SWIG_1(void * jarg1) {
38325   void * jresult ;
38326   Dali::Stage *arg1 = 0 ;
38327   Dali::Stage *result = 0 ;
38328
38329   arg1 = (Dali::Stage *)jarg1;
38330   if (!arg1) {
38331     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Stage const & type is null", 0);
38332     return 0;
38333   }
38334   {
38335     try {
38336       result = (Dali::Stage *)new Dali::Stage((Dali::Stage const &)*arg1);
38337     } catch (std::out_of_range& e) {
38338       {
38339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38340       };
38341     } catch (std::exception& e) {
38342       {
38343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38344       };
38345     } catch (Dali::DaliException e) {
38346       {
38347         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38348       };
38349     } catch (...) {
38350       {
38351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38352       };
38353     }
38354   }
38355
38356   jresult = (void *)result;
38357   return jresult;
38358 }
38359
38360
38361 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_Assign(void * jarg1, void * jarg2) {
38362   void * jresult ;
38363   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38364   Dali::Stage *arg2 = 0 ;
38365   Dali::Stage *result = 0 ;
38366
38367   arg1 = (Dali::Stage *)jarg1;
38368   arg2 = (Dali::Stage *)jarg2;
38369   if (!arg2) {
38370     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Stage const & type is null", 0);
38371     return 0;
38372   }
38373   {
38374     try {
38375       result = (Dali::Stage *) &(arg1)->operator =((Dali::Stage const &)*arg2);
38376     } catch (std::out_of_range& e) {
38377       {
38378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38379       };
38380     } catch (std::exception& e) {
38381       {
38382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38383       };
38384     } catch (Dali::DaliException e) {
38385       {
38386         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38387       };
38388     } catch (...) {
38389       {
38390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38391       };
38392     }
38393   }
38394
38395   jresult = (void *)result;
38396   return jresult;
38397 }
38398
38399
38400 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_Add(void * jarg1, void * jarg2) {
38401   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38402   Dali::Actor *arg2 = 0 ;
38403
38404   arg1 = (Dali::Stage *)jarg1;
38405   arg2 = (Dali::Actor *)jarg2;
38406   if (!arg2) {
38407     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
38408     return ;
38409   }
38410   {
38411     try {
38412       (arg1)->Add(*arg2);
38413     } catch (std::out_of_range& e) {
38414       {
38415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38416       };
38417     } catch (std::exception& e) {
38418       {
38419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38420       };
38421     } catch (Dali::DaliException e) {
38422       {
38423         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38424       };
38425     } catch (...) {
38426       {
38427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38428       };
38429     }
38430   }
38431
38432 }
38433
38434
38435 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_Remove(void * jarg1, void * jarg2) {
38436   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38437   Dali::Actor *arg2 = 0 ;
38438
38439   arg1 = (Dali::Stage *)jarg1;
38440   arg2 = (Dali::Actor *)jarg2;
38441   if (!arg2) {
38442     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
38443     return ;
38444   }
38445   {
38446     try {
38447       (arg1)->Remove(*arg2);
38448     } catch (std::out_of_range& e) {
38449       {
38450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38451       };
38452     } catch (std::exception& e) {
38453       {
38454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38455       };
38456     } catch (Dali::DaliException e) {
38457       {
38458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38459       };
38460     } catch (...) {
38461       {
38462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38463       };
38464     }
38465   }
38466
38467 }
38468
38469
38470 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetSize(void * jarg1) {
38471   void * jresult ;
38472   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38473   Dali::Vector2 result;
38474
38475   arg1 = (Dali::Stage *)jarg1;
38476   {
38477     try {
38478       result = ((Dali::Stage const *)arg1)->GetSize();
38479     } catch (std::out_of_range& e) {
38480       {
38481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38482       };
38483     } catch (std::exception& e) {
38484       {
38485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38486       };
38487     } catch (Dali::DaliException e) {
38488       {
38489         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38490       };
38491     } catch (...) {
38492       {
38493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38494       };
38495     }
38496   }
38497
38498   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
38499   return jresult;
38500 }
38501
38502
38503 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetRenderTaskList(void * jarg1) {
38504   void * jresult ;
38505   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38506   Dali::RenderTaskList result;
38507
38508   arg1 = (Dali::Stage *)jarg1;
38509   {
38510     try {
38511       result = ((Dali::Stage const *)arg1)->GetRenderTaskList();
38512     } catch (std::out_of_range& e) {
38513       {
38514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38515       };
38516     } catch (std::exception& e) {
38517       {
38518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38519       };
38520     } catch (Dali::DaliException e) {
38521       {
38522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38523       };
38524     } catch (...) {
38525       {
38526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38527       };
38528     }
38529   }
38530
38531   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
38532   return jresult;
38533 }
38534
38535
38536 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_GetLayerCount(void * jarg1) {
38537   unsigned int jresult ;
38538   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38539   unsigned int result;
38540
38541   arg1 = (Dali::Stage *)jarg1;
38542   {
38543     try {
38544       result = (unsigned int)((Dali::Stage const *)arg1)->GetLayerCount();
38545     } catch (std::out_of_range& e) {
38546       {
38547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38548       };
38549     } catch (std::exception& e) {
38550       {
38551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38552       };
38553     } catch (Dali::DaliException e) {
38554       {
38555         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38556       };
38557     } catch (...) {
38558       {
38559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38560       };
38561     }
38562   }
38563
38564   jresult = result;
38565   return jresult;
38566 }
38567
38568
38569 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetLayer(void * jarg1, unsigned int jarg2) {
38570   void * jresult ;
38571   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38572   unsigned int arg2 ;
38573   Dali::Layer result;
38574
38575   arg1 = (Dali::Stage *)jarg1;
38576   arg2 = (unsigned int)jarg2;
38577   {
38578     try {
38579       result = ((Dali::Stage const *)arg1)->GetLayer(arg2);
38580     } catch (std::out_of_range& e) {
38581       {
38582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38583       };
38584     } catch (std::exception& e) {
38585       {
38586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38587       };
38588     } catch (Dali::DaliException e) {
38589       {
38590         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38591       };
38592     } catch (...) {
38593       {
38594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38595       };
38596     }
38597   }
38598
38599   jresult = new Dali::Layer((const Dali::Layer &)result);
38600   return jresult;
38601 }
38602
38603
38604 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetRootLayer(void * jarg1) {
38605   void * jresult ;
38606   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38607   Dali::Layer result;
38608
38609   arg1 = (Dali::Stage *)jarg1;
38610   {
38611     try {
38612       result = ((Dali::Stage const *)arg1)->GetRootLayer();
38613     } catch (std::out_of_range& e) {
38614       {
38615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38616       };
38617     } catch (std::exception& e) {
38618       {
38619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38620       };
38621     } catch (Dali::DaliException e) {
38622       {
38623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38624       };
38625     } catch (...) {
38626       {
38627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38628       };
38629     }
38630   }
38631
38632   jresult = new Dali::Layer((const Dali::Layer &)result);
38633   return jresult;
38634 }
38635
38636
38637 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_SetBackgroundColor(void * jarg1, void * jarg2) {
38638   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38639   Dali::Vector4 arg2 ;
38640   Dali::Vector4 *argp2 ;
38641
38642   arg1 = (Dali::Stage *)jarg1;
38643   argp2 = (Dali::Vector4 *)jarg2;
38644   if (!argp2) {
38645     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector4", 0);
38646     return ;
38647   }
38648   arg2 = *argp2;
38649   {
38650     try {
38651       (arg1)->SetBackgroundColor(arg2);
38652     } catch (std::out_of_range& e) {
38653       {
38654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38655       };
38656     } catch (std::exception& e) {
38657       {
38658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38659       };
38660     } catch (Dali::DaliException e) {
38661       {
38662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38663       };
38664     } catch (...) {
38665       {
38666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38667       };
38668     }
38669   }
38670
38671 }
38672
38673
38674 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetBackgroundColor(void * jarg1) {
38675   void * jresult ;
38676   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38677   Dali::Vector4 result;
38678
38679   arg1 = (Dali::Stage *)jarg1;
38680   {
38681     try {
38682       result = ((Dali::Stage const *)arg1)->GetBackgroundColor();
38683     } catch (std::out_of_range& e) {
38684       {
38685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38686       };
38687     } catch (std::exception& e) {
38688       {
38689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38690       };
38691     } catch (Dali::DaliException e) {
38692       {
38693         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38694       };
38695     } catch (...) {
38696       {
38697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38698       };
38699     }
38700   }
38701
38702   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
38703   return jresult;
38704 }
38705
38706
38707 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetDpi(void * jarg1) {
38708   void * jresult ;
38709   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38710   Dali::Vector2 result;
38711
38712   arg1 = (Dali::Stage *)jarg1;
38713   {
38714     try {
38715       result = ((Dali::Stage const *)arg1)->GetDpi();
38716     } catch (std::out_of_range& e) {
38717       {
38718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38719       };
38720     } catch (std::exception& e) {
38721       {
38722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38723       };
38724     } catch (Dali::DaliException e) {
38725       {
38726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38727       };
38728     } catch (...) {
38729       {
38730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38731       };
38732     }
38733   }
38734
38735   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
38736   return jresult;
38737 }
38738
38739
38740 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetObjectRegistry(void * jarg1) {
38741   void * jresult ;
38742   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38743   Dali::ObjectRegistry result;
38744
38745   arg1 = (Dali::Stage *)jarg1;
38746   {
38747     try {
38748       result = ((Dali::Stage const *)arg1)->GetObjectRegistry();
38749     } catch (std::out_of_range& e) {
38750       {
38751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38752       };
38753     } catch (std::exception& e) {
38754       {
38755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38756       };
38757     } catch (Dali::DaliException e) {
38758       {
38759         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38760       };
38761     } catch (...) {
38762       {
38763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38764       };
38765     }
38766   }
38767
38768   jresult = new Dali::ObjectRegistry((const Dali::ObjectRegistry &)result);
38769   return jresult;
38770 }
38771
38772
38773 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_KeepRendering(void * jarg1, float jarg2) {
38774   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38775   float arg2 ;
38776
38777   arg1 = (Dali::Stage *)jarg1;
38778   arg2 = (float)jarg2;
38779   {
38780     try {
38781       (arg1)->KeepRendering(arg2);
38782     } catch (std::out_of_range& e) {
38783       {
38784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38785       };
38786     } catch (std::exception& e) {
38787       {
38788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38789       };
38790     } catch (Dali::DaliException e) {
38791       {
38792         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38793       };
38794     } catch (...) {
38795       {
38796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38797       };
38798     }
38799   }
38800
38801 }
38802
38803
38804 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_KeyEventSignal(void * jarg1) {
38805   void * jresult ;
38806   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38807   Dali::Stage::KeyEventSignalType *result = 0 ;
38808
38809   arg1 = (Dali::Stage *)jarg1;
38810   {
38811     try {
38812       result = (Dali::Stage::KeyEventSignalType *) &(arg1)->KeyEventSignal();
38813     } catch (std::out_of_range& e) {
38814       {
38815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38816       };
38817     } catch (std::exception& e) {
38818       {
38819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38820       };
38821     } catch (Dali::DaliException e) {
38822       {
38823         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38824       };
38825     } catch (...) {
38826       {
38827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38828       };
38829     }
38830   }
38831
38832   jresult = (void *)result;
38833   return jresult;
38834 }
38835
38836
38837 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_EventProcessingFinishedSignal(void * jarg1) {
38838   void * jresult ;
38839   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38840   Dali::Stage::EventProcessingFinishedSignalType *result = 0 ;
38841
38842   arg1 = (Dali::Stage *)jarg1;
38843   {
38844     try {
38845       result = (Dali::Stage::EventProcessingFinishedSignalType *) &(arg1)->EventProcessingFinishedSignal();
38846     } catch (std::out_of_range& e) {
38847       {
38848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38849       };
38850     } catch (std::exception& e) {
38851       {
38852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38853       };
38854     } catch (Dali::DaliException e) {
38855       {
38856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38857       };
38858     } catch (...) {
38859       {
38860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38861       };
38862     }
38863   }
38864
38865   jresult = (void *)result;
38866   return jresult;
38867 }
38868
38869
38870 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_TouchSignal(void * jarg1) {
38871   void * jresult ;
38872   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38873   Dali::Stage::TouchSignalType *result = 0 ;
38874
38875   arg1 = (Dali::Stage *)jarg1;
38876   {
38877     try {
38878       result = (Dali::Stage::TouchSignalType *) &(arg1)->TouchSignal();
38879     } catch (std::out_of_range& e) {
38880       {
38881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38882       };
38883     } catch (std::exception& e) {
38884       {
38885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38886       };
38887     } catch (Dali::DaliException e) {
38888       {
38889         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38890       };
38891     } catch (...) {
38892       {
38893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38894       };
38895     }
38896   }
38897
38898   jresult = (void *)result;
38899   return jresult;
38900 }
38901
38902
38903 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_WheelEventSignal(void * jarg1) {
38904   void * jresult ;
38905   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38906   Dali::Stage::WheelEventSignalType *result = 0 ;
38907
38908   arg1 = (Dali::Stage *)jarg1;
38909   {
38910     try {
38911       result = (Dali::Stage::WheelEventSignalType *) &(arg1)->WheelEventSignal();
38912     } catch (std::out_of_range& e) {
38913       {
38914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38915       };
38916     } catch (std::exception& e) {
38917       {
38918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38919       };
38920     } catch (Dali::DaliException e) {
38921       {
38922         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38923       };
38924     } catch (...) {
38925       {
38926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38927       };
38928     }
38929   }
38930
38931   jresult = (void *)result;
38932   return jresult;
38933 }
38934
38935
38936 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextLostSignal(void * jarg1) {
38937   void * jresult ;
38938   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38939   Dali::Stage::ContextStatusSignal *result = 0 ;
38940
38941   arg1 = (Dali::Stage *)jarg1;
38942   {
38943     try {
38944       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextLostSignal();
38945     } catch (std::out_of_range& e) {
38946       {
38947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38948       };
38949     } catch (std::exception& e) {
38950       {
38951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38952       };
38953     } catch (Dali::DaliException e) {
38954       {
38955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38956       };
38957     } catch (...) {
38958       {
38959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38960       };
38961     }
38962   }
38963
38964   jresult = (void *)result;
38965   return jresult;
38966 }
38967
38968
38969 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextRegainedSignal(void * jarg1) {
38970   void * jresult ;
38971   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38972   Dali::Stage::ContextStatusSignal *result = 0 ;
38973
38974   arg1 = (Dali::Stage *)jarg1;
38975   {
38976     try {
38977       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextRegainedSignal();
38978     } catch (std::out_of_range& e) {
38979       {
38980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38981       };
38982     } catch (std::exception& e) {
38983       {
38984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38985       };
38986     } catch (Dali::DaliException e) {
38987       {
38988         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38989       };
38990     } catch (...) {
38991       {
38992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38993       };
38994     }
38995   }
38996
38997   jresult = (void *)result;
38998   return jresult;
38999 }
39000
39001
39002 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_SceneCreatedSignal(void * jarg1) {
39003   void * jresult ;
39004   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
39005   Dali::Stage::SceneCreatedSignalType *result = 0 ;
39006
39007   arg1 = (Dali::Stage *)jarg1;
39008   {
39009     try {
39010       result = (Dali::Stage::SceneCreatedSignalType *) &(arg1)->SceneCreatedSignal();
39011     } catch (std::out_of_range& e) {
39012       {
39013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39014       };
39015     } catch (std::exception& e) {
39016       {
39017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39018       };
39019     } catch (Dali::DaliException e) {
39020       {
39021         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39022       };
39023     } catch (...) {
39024       {
39025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39026       };
39027     }
39028   }
39029
39030   jresult = (void *)result;
39031   return jresult;
39032 }
39033
39034 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_SetRenderingBehavior(void * jarg1, int jarg2) {
39035   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
39036   Dali::DevelStage::Rendering arg2 ;
39037
39038   arg1 = (Dali::Stage *)jarg1;
39039   arg2 = (Dali::DevelStage::Rendering)jarg2;
39040   {
39041     try {
39042       DevelStage::SetRenderingBehavior(*arg1,arg2);
39043     } catch (std::out_of_range& e) {
39044       {
39045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39046       };
39047     } catch (std::exception& e) {
39048       {
39049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39050       };
39051     } catch (Dali::DaliException e) {
39052       {
39053         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39054       };
39055     } catch (...) {
39056       {
39057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39058       };
39059     }
39060   }
39061
39062 }
39063
39064 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Stage_GetRenderingBehavior(void * jarg1) {
39065
39066   int jresult ;
39067   int result ;
39068   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
39069
39070   arg1 = (Dali::Stage *)jarg1;
39071   {
39072     try {
39073       result = (int)(DevelStage::GetRenderingBehavior(*arg1));
39074     } catch (std::out_of_range& e) {
39075       {
39076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39077       };
39078     } catch (std::exception& e) {
39079       {
39080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39081       };
39082     } catch (Dali::DaliException e) {
39083       {
39084         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39085       };
39086     } catch (...) {
39087       {
39088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39089       };
39090     }
39091   }
39092
39093   jresult = result;
39094   return jresult;
39095 }
39096
39097 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RelayoutContainer(void * jarg1) {
39098   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
39099
39100   arg1 = (Dali::RelayoutContainer *)jarg1;
39101   {
39102     try {
39103       delete arg1;
39104     } catch (std::out_of_range& e) {
39105       {
39106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39107       };
39108     } catch (std::exception& e) {
39109       {
39110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39111       };
39112     } catch (Dali::DaliException e) {
39113       {
39114         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39115       };
39116     } catch (...) {
39117       {
39118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39119       };
39120     }
39121   }
39122
39123 }
39124
39125
39126 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RelayoutContainer_Add(void * jarg1, void * jarg2, void * jarg3) {
39127   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
39128   Dali::Actor *arg2 = 0 ;
39129   Dali::Vector2 *arg3 = 0 ;
39130
39131   arg1 = (Dali::RelayoutContainer *)jarg1;
39132   arg2 = (Dali::Actor *)jarg2;
39133   if (!arg2) {
39134     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
39135     return ;
39136   }
39137   arg3 = (Dali::Vector2 *)jarg3;
39138   if (!arg3) {
39139     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
39140     return ;
39141   }
39142   {
39143     try {
39144       (arg1)->Add((Dali::Actor const &)*arg2,(Dali::Vector2 const &)*arg3);
39145     } catch (std::out_of_range& e) {
39146       {
39147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39148       };
39149     } catch (std::exception& e) {
39150       {
39151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39152       };
39153     } catch (Dali::DaliException e) {
39154       {
39155         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39156       };
39157     } catch (...) {
39158       {
39159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39160       };
39161     }
39162   }
39163
39164 }
39165
39166
39167 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_Self(void * jarg1) {
39168   void * jresult ;
39169   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39170   Dali::CustomActor result;
39171
39172   arg1 = (Dali::CustomActorImpl *)jarg1;
39173   {
39174     try {
39175       result = ((Dali::CustomActorImpl const *)arg1)->Self();
39176     } catch (std::out_of_range& e) {
39177       {
39178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39179       };
39180     } catch (std::exception& e) {
39181       {
39182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39183       };
39184     } catch (Dali::DaliException e) {
39185       {
39186         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39187       };
39188     } catch (...) {
39189       {
39190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39191       };
39192     }
39193   }
39194
39195   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
39196   return jresult;
39197 }
39198
39199
39200 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnStageConnection(void * jarg1, int jarg2) {
39201   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39202   int arg2 ;
39203
39204   arg1 = (Dali::CustomActorImpl *)jarg1;
39205   arg2 = (int)jarg2;
39206   {
39207     try {
39208       (arg1)->OnStageConnection(arg2);
39209     } catch (std::out_of_range& e) {
39210       {
39211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39212       };
39213     } catch (std::exception& e) {
39214       {
39215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39216       };
39217     } catch (Dali::DaliException e) {
39218       {
39219         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39220       };
39221     } catch (...) {
39222       {
39223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39224       };
39225     }
39226   }
39227
39228 }
39229
39230
39231 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnStageDisconnection(void * jarg1) {
39232   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39233
39234   arg1 = (Dali::CustomActorImpl *)jarg1;
39235   {
39236     try {
39237       (arg1)->OnStageDisconnection();
39238     } catch (std::out_of_range& e) {
39239       {
39240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39241       };
39242     } catch (std::exception& e) {
39243       {
39244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39245       };
39246     } catch (Dali::DaliException e) {
39247       {
39248         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39249       };
39250     } catch (...) {
39251       {
39252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39253       };
39254     }
39255   }
39256
39257 }
39258
39259
39260 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildAdd(void * jarg1, void * jarg2) {
39261   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39262   Dali::Actor *arg2 = 0 ;
39263
39264   arg1 = (Dali::CustomActorImpl *)jarg1;
39265   arg2 = (Dali::Actor *)jarg2;
39266   if (!arg2) {
39267     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
39268     return ;
39269   }
39270   {
39271     try {
39272       (arg1)->OnChildAdd(*arg2);
39273     } catch (std::out_of_range& e) {
39274       {
39275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39276       };
39277     } catch (std::exception& e) {
39278       {
39279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39280       };
39281     } catch (Dali::DaliException e) {
39282       {
39283         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39284       };
39285     } catch (...) {
39286       {
39287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39288       };
39289     }
39290   }
39291
39292 }
39293
39294
39295 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildRemove(void * jarg1, void * jarg2) {
39296   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39297   Dali::Actor *arg2 = 0 ;
39298
39299   arg1 = (Dali::CustomActorImpl *)jarg1;
39300   arg2 = (Dali::Actor *)jarg2;
39301   if (!arg2) {
39302     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
39303     return ;
39304   }
39305   {
39306     try {
39307       (arg1)->OnChildRemove(*arg2);
39308     } catch (std::out_of_range& e) {
39309       {
39310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39311       };
39312     } catch (std::exception& e) {
39313       {
39314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39315       };
39316     } catch (Dali::DaliException e) {
39317       {
39318         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39319       };
39320     } catch (...) {
39321       {
39322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39323       };
39324     }
39325   }
39326
39327 }
39328
39329
39330 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
39331   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39332   Dali::Property::Index arg2 ;
39333   Dali::Property::Value arg3 ;
39334   Dali::Property::Value *argp3 ;
39335
39336   arg1 = (Dali::CustomActorImpl *)jarg1;
39337   arg2 = (Dali::Property::Index)jarg2;
39338   argp3 = (Dali::Property::Value *)jarg3;
39339   if (!argp3) {
39340     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39341     return ;
39342   }
39343   arg3 = *argp3;
39344   {
39345     try {
39346       (arg1)->OnPropertySet(arg2,arg3);
39347     } catch (std::out_of_range& e) {
39348       {
39349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39350       };
39351     } catch (std::exception& e) {
39352       {
39353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39354       };
39355     } catch (Dali::DaliException e) {
39356       {
39357         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39358       };
39359     } catch (...) {
39360       {
39361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39362       };
39363     }
39364   }
39365
39366 }
39367
39368
39369 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeSet(void * jarg1, void * jarg2) {
39370   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39371   Dali::Vector3 *arg2 = 0 ;
39372
39373   arg1 = (Dali::CustomActorImpl *)jarg1;
39374   arg2 = (Dali::Vector3 *)jarg2;
39375   if (!arg2) {
39376     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
39377     return ;
39378   }
39379   {
39380     try {
39381       (arg1)->OnSizeSet((Dali::Vector3 const &)*arg2);
39382     } catch (std::out_of_range& e) {
39383       {
39384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39385       };
39386     } catch (std::exception& e) {
39387       {
39388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39389       };
39390     } catch (Dali::DaliException e) {
39391       {
39392         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39393       };
39394     } catch (...) {
39395       {
39396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39397       };
39398     }
39399   }
39400
39401 }
39402
39403 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
39404   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39405   Dali::Animation *arg2 = 0 ;
39406   Dali::Vector3 *arg3 = 0 ;
39407
39408   arg1 = (Dali::CustomActorImpl *)jarg1;
39409   arg2 = (Dali::Animation *)jarg2;
39410   if (!arg2) {
39411     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
39412     return ;
39413   }
39414   arg3 = (Dali::Vector3 *)jarg3;
39415   if (!arg3) {
39416     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
39417     return ;
39418   }
39419   {
39420     try {
39421       (arg1)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
39422     } catch (std::out_of_range& e) {
39423       {
39424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39425       };
39426     } catch (std::exception& e) {
39427       {
39428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39429       };
39430     } catch (Dali::DaliException e) {
39431       {
39432         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39433       };
39434     } catch (...) {
39435       {
39436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39437       };
39438     }
39439   }
39440
39441 }
39442
39443
39444 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnTouchEvent(void * jarg1, void * jarg2) {
39445   unsigned int jresult ;
39446   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39447   Dali::TouchEvent *arg2 = 0 ;
39448   bool result;
39449
39450   arg1 = (Dali::CustomActorImpl *)jarg1;
39451   arg2 = (Dali::TouchEvent *)jarg2;
39452   if (!arg2) {
39453     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
39454     return 0;
39455   }
39456   {
39457     try {
39458       result = (bool)(arg1)->OnTouchEvent((Dali::TouchEvent const &)*arg2);
39459     } catch (std::out_of_range& e) {
39460       {
39461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39462       };
39463     } catch (std::exception& e) {
39464       {
39465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39466       };
39467     } catch (Dali::DaliException e) {
39468       {
39469         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39470       };
39471     } catch (...) {
39472       {
39473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39474       };
39475     }
39476   }
39477
39478   jresult = result;
39479   return jresult;
39480 }
39481
39482
39483 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnHoverEvent(void * jarg1, void * jarg2) {
39484   unsigned int jresult ;
39485   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39486   Dali::HoverEvent *arg2 = 0 ;
39487   bool result;
39488
39489   arg1 = (Dali::CustomActorImpl *)jarg1;
39490   arg2 = (Dali::HoverEvent *)jarg2;
39491   if (!arg2) {
39492     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
39493     return 0;
39494   }
39495   {
39496     try {
39497       result = (bool)(arg1)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
39498     } catch (std::out_of_range& e) {
39499       {
39500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39501       };
39502     } catch (std::exception& e) {
39503       {
39504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39505       };
39506     } catch (Dali::DaliException e) {
39507       {
39508         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39509       };
39510     } catch (...) {
39511       {
39512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39513       };
39514     }
39515   }
39516
39517   jresult = result;
39518   return jresult;
39519 }
39520
39521
39522 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnKeyEvent(void * jarg1, void * jarg2) {
39523   unsigned int jresult ;
39524   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39525   Dali::KeyEvent *arg2 = 0 ;
39526   bool result;
39527
39528   arg1 = (Dali::CustomActorImpl *)jarg1;
39529   arg2 = (Dali::KeyEvent *)jarg2;
39530   if (!arg2) {
39531     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
39532     return 0;
39533   }
39534   {
39535     try {
39536       result = (bool)(arg1)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
39537     } catch (std::out_of_range& e) {
39538       {
39539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39540       };
39541     } catch (std::exception& e) {
39542       {
39543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39544       };
39545     } catch (Dali::DaliException e) {
39546       {
39547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39548       };
39549     } catch (...) {
39550       {
39551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39552       };
39553     }
39554   }
39555
39556   jresult = result;
39557   return jresult;
39558 }
39559
39560
39561 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnWheelEvent(void * jarg1, void * jarg2) {
39562   unsigned int jresult ;
39563   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39564   Dali::WheelEvent *arg2 = 0 ;
39565   bool result;
39566
39567   arg1 = (Dali::CustomActorImpl *)jarg1;
39568   arg2 = (Dali::WheelEvent *)jarg2;
39569   if (!arg2) {
39570     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
39571     return 0;
39572   }
39573   {
39574     try {
39575       result = (bool)(arg1)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
39576     } catch (std::out_of_range& e) {
39577       {
39578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39579       };
39580     } catch (std::exception& e) {
39581       {
39582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39583       };
39584     } catch (Dali::DaliException e) {
39585       {
39586         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39587       };
39588     } catch (...) {
39589       {
39590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39591       };
39592     }
39593   }
39594
39595   jresult = result;
39596   return jresult;
39597 }
39598
39599
39600 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
39601   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39602   Dali::Vector2 *arg2 = 0 ;
39603   Dali::RelayoutContainer *arg3 = 0 ;
39604
39605   arg1 = (Dali::CustomActorImpl *)jarg1;
39606   arg2 = (Dali::Vector2 *)jarg2;
39607   if (!arg2) {
39608     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
39609     return ;
39610   }
39611   arg3 = (Dali::RelayoutContainer *)jarg3;
39612   if (!arg3) {
39613     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
39614     return ;
39615   }
39616   {
39617     try {
39618       (arg1)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
39619     } catch (std::out_of_range& e) {
39620       {
39621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39622       };
39623     } catch (std::exception& e) {
39624       {
39625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39626       };
39627     } catch (Dali::DaliException e) {
39628       {
39629         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39630       };
39631     } catch (...) {
39632       {
39633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39634       };
39635     }
39636   }
39637
39638 }
39639
39640
39641 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
39642   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39643   Dali::ResizePolicy::Type arg2 ;
39644   Dali::Dimension::Type arg3 ;
39645
39646   arg1 = (Dali::CustomActorImpl *)jarg1;
39647   arg2 = (Dali::ResizePolicy::Type)jarg2;
39648   arg3 = (Dali::Dimension::Type)jarg3;
39649   {
39650     try {
39651       (arg1)->OnSetResizePolicy(arg2,arg3);
39652     } catch (std::out_of_range& e) {
39653       {
39654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39655       };
39656     } catch (std::exception& e) {
39657       {
39658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39659       };
39660     } catch (Dali::DaliException e) {
39661       {
39662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39663       };
39664     } catch (...) {
39665       {
39666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39667       };
39668     }
39669   }
39670
39671 }
39672
39673
39674 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetNaturalSize(void * jarg1) {
39675   void * jresult ;
39676   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39677   Dali::Vector3 result;
39678
39679   arg1 = (Dali::CustomActorImpl *)jarg1;
39680   {
39681     try {
39682       result = (arg1)->GetNaturalSize();
39683     } catch (std::out_of_range& e) {
39684       {
39685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39686       };
39687     } catch (std::exception& e) {
39688       {
39689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39690       };
39691     } catch (Dali::DaliException e) {
39692       {
39693         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39694       };
39695     } catch (...) {
39696       {
39697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39698       };
39699     }
39700   }
39701
39702   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
39703   return jresult;
39704 }
39705
39706
39707 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
39708   float jresult ;
39709   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39710   Dali::Actor *arg2 = 0 ;
39711   Dali::Dimension::Type arg3 ;
39712   float result;
39713
39714   arg1 = (Dali::CustomActorImpl *)jarg1;
39715   arg2 = (Dali::Actor *)jarg2;
39716   if (!arg2) {
39717     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
39718     return 0;
39719   }
39720   arg3 = (Dali::Dimension::Type)jarg3;
39721   {
39722     try {
39723       result = (float)(arg1)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
39724     } catch (std::out_of_range& e) {
39725       {
39726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39727       };
39728     } catch (std::exception& e) {
39729       {
39730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39731       };
39732     } catch (Dali::DaliException e) {
39733       {
39734         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39735       };
39736     } catch (...) {
39737       {
39738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39739       };
39740     }
39741   }
39742
39743   jresult = result;
39744   return jresult;
39745 }
39746
39747
39748 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetHeightForWidth(void * jarg1, float jarg2) {
39749   float jresult ;
39750   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39751   float arg2 ;
39752   float result;
39753
39754   arg1 = (Dali::CustomActorImpl *)jarg1;
39755   arg2 = (float)jarg2;
39756   {
39757     try {
39758       result = (float)(arg1)->GetHeightForWidth(arg2);
39759     } catch (std::out_of_range& e) {
39760       {
39761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39762       };
39763     } catch (std::exception& e) {
39764       {
39765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39766       };
39767     } catch (Dali::DaliException e) {
39768       {
39769         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39770       };
39771     } catch (...) {
39772       {
39773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39774       };
39775     }
39776   }
39777
39778   jresult = result;
39779   return jresult;
39780 }
39781
39782
39783 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetWidthForHeight(void * jarg1, float jarg2) {
39784   float jresult ;
39785   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39786   float arg2 ;
39787   float result;
39788
39789   arg1 = (Dali::CustomActorImpl *)jarg1;
39790   arg2 = (float)jarg2;
39791   {
39792     try {
39793       result = (float)(arg1)->GetWidthForHeight(arg2);
39794     } catch (std::out_of_range& e) {
39795       {
39796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39797       };
39798     } catch (std::exception& e) {
39799       {
39800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39801       };
39802     } catch (Dali::DaliException e) {
39803       {
39804         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39805       };
39806     } catch (...) {
39807       {
39808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39809       };
39810     }
39811   }
39812
39813   jresult = result;
39814   return jresult;
39815 }
39816
39817
39818 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
39819   unsigned int jresult ;
39820   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39821   Dali::Dimension::Type arg2 ;
39822   bool result;
39823
39824   arg1 = (Dali::CustomActorImpl *)jarg1;
39825   arg2 = (Dali::Dimension::Type)jarg2;
39826   {
39827     try {
39828       result = (bool)(arg1)->RelayoutDependentOnChildren(arg2);
39829     } catch (std::out_of_range& e) {
39830       {
39831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39832       };
39833     } catch (std::exception& e) {
39834       {
39835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39836       };
39837     } catch (Dali::DaliException e) {
39838       {
39839         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39840       };
39841     } catch (...) {
39842       {
39843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39844       };
39845     }
39846   }
39847
39848   jresult = result;
39849   return jresult;
39850 }
39851
39852
39853 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
39854   unsigned int jresult ;
39855   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39856   bool result;
39857
39858   arg1 = (Dali::CustomActorImpl *)jarg1;
39859   {
39860     try {
39861       result = (bool)(arg1)->RelayoutDependentOnChildren();
39862     } catch (std::out_of_range& e) {
39863       {
39864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39865       };
39866     } catch (std::exception& e) {
39867       {
39868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39869       };
39870     } catch (Dali::DaliException e) {
39871       {
39872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39873       };
39874     } catch (...) {
39875       {
39876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39877       };
39878     }
39879   }
39880
39881   jresult = result;
39882   return jresult;
39883 }
39884
39885
39886 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
39887   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39888   Dali::Dimension::Type arg2 ;
39889
39890   arg1 = (Dali::CustomActorImpl *)jarg1;
39891   arg2 = (Dali::Dimension::Type)jarg2;
39892   {
39893     try {
39894       (arg1)->OnCalculateRelayoutSize(arg2);
39895     } catch (std::out_of_range& e) {
39896       {
39897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39898       };
39899     } catch (std::exception& e) {
39900       {
39901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39902       };
39903     } catch (Dali::DaliException e) {
39904       {
39905         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39906       };
39907     } catch (...) {
39908       {
39909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39910       };
39911     }
39912   }
39913
39914 }
39915
39916
39917 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
39918   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39919   float arg2 ;
39920   Dali::Dimension::Type arg3 ;
39921
39922   arg1 = (Dali::CustomActorImpl *)jarg1;
39923   arg2 = (float)jarg2;
39924   arg3 = (Dali::Dimension::Type)jarg3;
39925   {
39926     try {
39927       (arg1)->OnLayoutNegotiated(arg2,arg3);
39928     } catch (std::out_of_range& e) {
39929       {
39930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39931       };
39932     } catch (std::exception& e) {
39933       {
39934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39935       };
39936     } catch (Dali::DaliException e) {
39937       {
39938         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39939       };
39940     } catch (...) {
39941       {
39942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39943       };
39944     }
39945   }
39946
39947 }
39948
39949
39950 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresTouchEvents(void * jarg1) {
39951   unsigned int jresult ;
39952   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39953   bool result;
39954
39955   arg1 = (Dali::CustomActorImpl *)jarg1;
39956   {
39957     try {
39958       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresTouchEvents();
39959     } catch (std::out_of_range& e) {
39960       {
39961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39962       };
39963     } catch (std::exception& e) {
39964       {
39965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39966       };
39967     } catch (Dali::DaliException e) {
39968       {
39969         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39970       };
39971     } catch (...) {
39972       {
39973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39974       };
39975     }
39976   }
39977
39978   jresult = result;
39979   return jresult;
39980 }
39981
39982
39983 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresHoverEvents(void * jarg1) {
39984   unsigned int jresult ;
39985   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39986   bool result;
39987
39988   arg1 = (Dali::CustomActorImpl *)jarg1;
39989   {
39990     try {
39991       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresHoverEvents();
39992     } catch (std::out_of_range& e) {
39993       {
39994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39995       };
39996     } catch (std::exception& e) {
39997       {
39998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39999       };
40000     } catch (Dali::DaliException e) {
40001       {
40002         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40003       };
40004     } catch (...) {
40005       {
40006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40007       };
40008     }
40009   }
40010
40011   jresult = result;
40012   return jresult;
40013 }
40014
40015
40016 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresWheelEvents(void * jarg1) {
40017   unsigned int jresult ;
40018   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
40019   bool result;
40020
40021   arg1 = (Dali::CustomActorImpl *)jarg1;
40022   {
40023     try {
40024       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresWheelEvents();
40025     } catch (std::out_of_range& e) {
40026       {
40027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40028       };
40029     } catch (std::exception& e) {
40030       {
40031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40032       };
40033     } catch (Dali::DaliException e) {
40034       {
40035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40036       };
40037     } catch (...) {
40038       {
40039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40040       };
40041     }
40042   }
40043
40044   jresult = result;
40045   return jresult;
40046 }
40047
40048
40049 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_IsRelayoutEnabled(void * jarg1) {
40050   unsigned int jresult ;
40051   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
40052   bool result;
40053
40054   arg1 = (Dali::CustomActorImpl *)jarg1;
40055   {
40056     try {
40057       result = (bool)((Dali::CustomActorImpl const *)arg1)->IsRelayoutEnabled();
40058     } catch (std::out_of_range& e) {
40059       {
40060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40061       };
40062     } catch (std::exception& e) {
40063       {
40064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40065       };
40066     } catch (Dali::DaliException e) {
40067       {
40068         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40069       };
40070     } catch (...) {
40071       {
40072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40073       };
40074     }
40075   }
40076
40077   jresult = result;
40078   return jresult;
40079 }
40080
40081
40082 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_0() {
40083   void * jresult ;
40084   Dali::CustomActor *result = 0 ;
40085
40086   {
40087     try {
40088       result = (Dali::CustomActor *)new Dali::CustomActor();
40089     } catch (std::out_of_range& e) {
40090       {
40091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40092       };
40093     } catch (std::exception& e) {
40094       {
40095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40096       };
40097     } catch (Dali::DaliException e) {
40098       {
40099         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40100       };
40101     } catch (...) {
40102       {
40103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40104       };
40105     }
40106   }
40107
40108   jresult = (void *)result;
40109   return jresult;
40110 }
40111
40112
40113 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_DownCast(void * jarg1) {
40114   void * jresult ;
40115   Dali::BaseHandle arg1 ;
40116   Dali::BaseHandle *argp1 ;
40117   Dali::CustomActor result;
40118
40119   argp1 = (Dali::BaseHandle *)jarg1;
40120   if (!argp1) {
40121     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40122     return 0;
40123   }
40124   arg1 = *argp1;
40125   {
40126     try {
40127       result = Dali::CustomActor::DownCast(arg1);
40128     } catch (std::out_of_range& e) {
40129       {
40130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40131       };
40132     } catch (std::exception& e) {
40133       {
40134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40135       };
40136     } catch (Dali::DaliException e) {
40137       {
40138         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40139       };
40140     } catch (...) {
40141       {
40142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40143       };
40144     }
40145   }
40146
40147   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
40148   return jresult;
40149 }
40150
40151
40152 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomActor(void * jarg1) {
40153   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
40154
40155   arg1 = (Dali::CustomActor *)jarg1;
40156   {
40157     try {
40158       delete arg1;
40159     } catch (std::out_of_range& e) {
40160       {
40161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40162       };
40163     } catch (std::exception& e) {
40164       {
40165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40166       };
40167     } catch (Dali::DaliException e) {
40168       {
40169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40170       };
40171     } catch (...) {
40172       {
40173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40174       };
40175     }
40176   }
40177
40178 }
40179
40180
40181 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_GetImplementation(void * jarg1) {
40182   void * jresult ;
40183   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
40184   Dali::CustomActorImpl *result = 0 ;
40185
40186   arg1 = (Dali::CustomActor *)jarg1;
40187   {
40188     try {
40189       result = (Dali::CustomActorImpl *) &((Dali::CustomActor const *)arg1)->GetImplementation();
40190     } catch (std::out_of_range& e) {
40191       {
40192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40193       };
40194     } catch (std::exception& e) {
40195       {
40196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40197       };
40198     } catch (Dali::DaliException e) {
40199       {
40200         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40201       };
40202     } catch (...) {
40203       {
40204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40205       };
40206     }
40207   }
40208
40209   jresult = (void *)result;
40210   return jresult;
40211 }
40212
40213
40214 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_1(void * jarg1) {
40215   void * jresult ;
40216   Dali::CustomActorImpl *arg1 = 0 ;
40217   Dali::CustomActor *result = 0 ;
40218
40219   arg1 = (Dali::CustomActorImpl *)jarg1;
40220   if (!arg1) {
40221     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActorImpl & type is null", 0);
40222     return 0;
40223   }
40224   {
40225     try {
40226       result = (Dali::CustomActor *)new Dali::CustomActor(*arg1);
40227     } catch (std::out_of_range& e) {
40228       {
40229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40230       };
40231     } catch (std::exception& e) {
40232       {
40233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40234       };
40235     } catch (Dali::DaliException e) {
40236       {
40237         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40238       };
40239     } catch (...) {
40240       {
40241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40242       };
40243     }
40244   }
40245
40246   jresult = (void *)result;
40247   return jresult;
40248 }
40249
40250
40251 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_2(void * jarg1) {
40252   void * jresult ;
40253   Dali::CustomActor *arg1 = 0 ;
40254   Dali::CustomActor *result = 0 ;
40255
40256   arg1 = (Dali::CustomActor *)jarg1;
40257   if (!arg1) {
40258     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
40259     return 0;
40260   }
40261   {
40262     try {
40263       result = (Dali::CustomActor *)new Dali::CustomActor((Dali::CustomActor const &)*arg1);
40264     } catch (std::out_of_range& e) {
40265       {
40266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40267       };
40268     } catch (std::exception& e) {
40269       {
40270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40271       };
40272     } catch (Dali::DaliException e) {
40273       {
40274         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40275       };
40276     } catch (...) {
40277       {
40278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40279       };
40280     }
40281   }
40282
40283   jresult = (void *)result;
40284   return jresult;
40285 }
40286
40287
40288 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_Assign(void * jarg1, void * jarg2) {
40289   void * jresult ;
40290   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
40291   Dali::CustomActor *arg2 = 0 ;
40292   Dali::CustomActor *result = 0 ;
40293
40294   arg1 = (Dali::CustomActor *)jarg1;
40295   arg2 = (Dali::CustomActor *)jarg2;
40296   if (!arg2) {
40297     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
40298     return 0;
40299   }
40300   {
40301     try {
40302       result = (Dali::CustomActor *) &(arg1)->operator =((Dali::CustomActor const &)*arg2);
40303     } catch (std::out_of_range& e) {
40304       {
40305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40306       };
40307     } catch (std::exception& e) {
40308       {
40309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40310       };
40311     } catch (Dali::DaliException e) {
40312       {
40313         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40314       };
40315     } catch (...) {
40316       {
40317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40318       };
40319     }
40320   }
40321
40322   jresult = (void *)result;
40323   return jresult;
40324 }
40325
40326
40327 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_POSITION_get() {
40328   int jresult ;
40329   int result;
40330
40331   result = (int)Dali::PanGestureDetector::Property::SCREEN_POSITION;
40332   jresult = (int)result;
40333   return jresult;
40334 }
40335
40336
40337 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_DISPLACEMENT_get() {
40338   int jresult ;
40339   int result;
40340
40341   result = (int)Dali::PanGestureDetector::Property::SCREEN_DISPLACEMENT;
40342   jresult = (int)result;
40343   return jresult;
40344 }
40345
40346
40347 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_VELOCITY_get() {
40348   int jresult ;
40349   int result;
40350
40351   result = (int)Dali::PanGestureDetector::Property::SCREEN_VELOCITY;
40352   jresult = (int)result;
40353   return jresult;
40354 }
40355
40356
40357 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_POSITION_get() {
40358   int jresult ;
40359   int result;
40360
40361   result = (int)Dali::PanGestureDetector::Property::LOCAL_POSITION;
40362   jresult = (int)result;
40363   return jresult;
40364 }
40365
40366
40367 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_DISPLACEMENT_get() {
40368   int jresult ;
40369   int result;
40370
40371   result = (int)Dali::PanGestureDetector::Property::LOCAL_DISPLACEMENT;
40372   jresult = (int)result;
40373   return jresult;
40374 }
40375
40376
40377 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_VELOCITY_get() {
40378   int jresult ;
40379   int result;
40380
40381   result = (int)Dali::PanGestureDetector::Property::LOCAL_VELOCITY;
40382   jresult = (int)result;
40383   return jresult;
40384 }
40385
40386
40387 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_PANNING_get() {
40388   int jresult ;
40389   int result;
40390
40391   result = (int)Dali::PanGestureDetector::Property::PANNING;
40392   jresult = (int)result;
40393   return jresult;
40394 }
40395
40396
40397 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector_Property() {
40398   void * jresult ;
40399   Dali::PanGestureDetector::Property *result = 0 ;
40400
40401   {
40402     try {
40403       result = (Dali::PanGestureDetector::Property *)new Dali::PanGestureDetector::Property();
40404     } catch (std::out_of_range& e) {
40405       {
40406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40407       };
40408     } catch (std::exception& e) {
40409       {
40410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40411       };
40412     } catch (Dali::DaliException e) {
40413       {
40414         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40415       };
40416     } catch (...) {
40417       {
40418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40419       };
40420     }
40421   }
40422
40423   jresult = (void *)result;
40424   return jresult;
40425 }
40426
40427
40428 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector_Property(void * jarg1) {
40429   Dali::PanGestureDetector::Property *arg1 = (Dali::PanGestureDetector::Property *) 0 ;
40430
40431   arg1 = (Dali::PanGestureDetector::Property *)jarg1;
40432   {
40433     try {
40434       delete arg1;
40435     } catch (std::out_of_range& e) {
40436       {
40437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40438       };
40439     } catch (std::exception& e) {
40440       {
40441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40442       };
40443     } catch (Dali::DaliException e) {
40444       {
40445         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40446       };
40447     } catch (...) {
40448       {
40449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40450       };
40451     }
40452   }
40453
40454 }
40455
40456
40457 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_LEFT_get() {
40458   void * jresult ;
40459   Dali::Radian *result = 0 ;
40460
40461   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_LEFT;
40462   jresult = (void *)result;
40463   return jresult;
40464 }
40465
40466
40467 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_RIGHT_get() {
40468   void * jresult ;
40469   Dali::Radian *result = 0 ;
40470
40471   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_RIGHT;
40472   jresult = (void *)result;
40473   return jresult;
40474 }
40475
40476
40477 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_UP_get() {
40478   void * jresult ;
40479   Dali::Radian *result = 0 ;
40480
40481   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_UP;
40482   jresult = (void *)result;
40483   return jresult;
40484 }
40485
40486
40487 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_DOWN_get() {
40488   void * jresult ;
40489   Dali::Radian *result = 0 ;
40490
40491   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_DOWN;
40492   jresult = (void *)result;
40493   return jresult;
40494 }
40495
40496
40497 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_HORIZONTAL_get() {
40498   void * jresult ;
40499   Dali::Radian *result = 0 ;
40500
40501   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_HORIZONTAL;
40502   jresult = (void *)result;
40503   return jresult;
40504 }
40505
40506
40507 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_VERTICAL_get() {
40508   void * jresult ;
40509   Dali::Radian *result = 0 ;
40510
40511   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_VERTICAL;
40512   jresult = (void *)result;
40513   return jresult;
40514 }
40515
40516
40517 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DEFAULT_THRESHOLD_get() {
40518   void * jresult ;
40519   Dali::Radian *result = 0 ;
40520
40521   result = (Dali::Radian *)&Dali::PanGestureDetector::DEFAULT_THRESHOLD;
40522   jresult = (void *)result;
40523   return jresult;
40524 }
40525
40526
40527 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_0() {
40528   void * jresult ;
40529   Dali::PanGestureDetector *result = 0 ;
40530
40531   {
40532     try {
40533       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector();
40534     } catch (std::out_of_range& e) {
40535       {
40536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40537       };
40538     } catch (std::exception& e) {
40539       {
40540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40541       };
40542     } catch (Dali::DaliException e) {
40543       {
40544         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40545       };
40546     } catch (...) {
40547       {
40548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40549       };
40550     }
40551   }
40552
40553   jresult = (void *)result;
40554   return jresult;
40555 }
40556
40557
40558 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_New() {
40559   void * jresult ;
40560   Dali::PanGestureDetector result;
40561
40562   {
40563     try {
40564       result = Dali::PanGestureDetector::New();
40565     } catch (std::out_of_range& e) {
40566       {
40567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40568       };
40569     } catch (std::exception& e) {
40570       {
40571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40572       };
40573     } catch (Dali::DaliException e) {
40574       {
40575         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40576       };
40577     } catch (...) {
40578       {
40579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40580       };
40581     }
40582   }
40583
40584   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
40585   return jresult;
40586 }
40587
40588
40589 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DownCast(void * jarg1) {
40590   void * jresult ;
40591   Dali::BaseHandle arg1 ;
40592   Dali::BaseHandle *argp1 ;
40593   Dali::PanGestureDetector result;
40594
40595   argp1 = (Dali::BaseHandle *)jarg1;
40596   if (!argp1) {
40597     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40598     return 0;
40599   }
40600   arg1 = *argp1;
40601   {
40602     try {
40603       result = Dali::PanGestureDetector::DownCast(arg1);
40604     } catch (std::out_of_range& e) {
40605       {
40606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40607       };
40608     } catch (std::exception& e) {
40609       {
40610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40611       };
40612     } catch (Dali::DaliException e) {
40613       {
40614         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40615       };
40616     } catch (...) {
40617       {
40618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40619       };
40620     }
40621   }
40622
40623   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
40624   return jresult;
40625 }
40626
40627
40628 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector(void * jarg1) {
40629   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40630
40631   arg1 = (Dali::PanGestureDetector *)jarg1;
40632   {
40633     try {
40634       delete arg1;
40635     } catch (std::out_of_range& e) {
40636       {
40637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40638       };
40639     } catch (std::exception& e) {
40640       {
40641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40642       };
40643     } catch (Dali::DaliException e) {
40644       {
40645         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40646       };
40647     } catch (...) {
40648       {
40649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40650       };
40651     }
40652   }
40653
40654 }
40655
40656
40657 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_1(void * jarg1) {
40658   void * jresult ;
40659   Dali::PanGestureDetector *arg1 = 0 ;
40660   Dali::PanGestureDetector *result = 0 ;
40661
40662   arg1 = (Dali::PanGestureDetector *)jarg1;
40663   if (!arg1) {
40664     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
40665     return 0;
40666   }
40667   {
40668     try {
40669       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector((Dali::PanGestureDetector const &)*arg1);
40670     } catch (std::out_of_range& e) {
40671       {
40672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40673       };
40674     } catch (std::exception& e) {
40675       {
40676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40677       };
40678     } catch (Dali::DaliException e) {
40679       {
40680         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40681       };
40682     } catch (...) {
40683       {
40684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40685       };
40686     }
40687   }
40688
40689   jresult = (void *)result;
40690   return jresult;
40691 }
40692
40693
40694 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_Assign(void * jarg1, void * jarg2) {
40695   void * jresult ;
40696   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40697   Dali::PanGestureDetector *arg2 = 0 ;
40698   Dali::PanGestureDetector *result = 0 ;
40699
40700   arg1 = (Dali::PanGestureDetector *)jarg1;
40701   arg2 = (Dali::PanGestureDetector *)jarg2;
40702   if (!arg2) {
40703     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
40704     return 0;
40705   }
40706   {
40707     try {
40708       result = (Dali::PanGestureDetector *) &(arg1)->operator =((Dali::PanGestureDetector const &)*arg2);
40709     } catch (std::out_of_range& e) {
40710       {
40711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40712       };
40713     } catch (std::exception& e) {
40714       {
40715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40716       };
40717     } catch (Dali::DaliException e) {
40718       {
40719         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40720       };
40721     } catch (...) {
40722       {
40723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40724       };
40725     }
40726   }
40727
40728   jresult = (void *)result;
40729   return jresult;
40730 }
40731
40732
40733 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMinimumTouchesRequired(void * jarg1, unsigned int jarg2) {
40734   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40735   unsigned int arg2 ;
40736
40737   arg1 = (Dali::PanGestureDetector *)jarg1;
40738   arg2 = (unsigned int)jarg2;
40739   {
40740     try {
40741       (arg1)->SetMinimumTouchesRequired(arg2);
40742     } catch (std::out_of_range& e) {
40743       {
40744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40745       };
40746     } catch (std::exception& e) {
40747       {
40748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40749       };
40750     } catch (Dali::DaliException e) {
40751       {
40752         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40753       };
40754     } catch (...) {
40755       {
40756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40757       };
40758     }
40759   }
40760
40761 }
40762
40763
40764 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMaximumTouchesRequired(void * jarg1, unsigned int jarg2) {
40765   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40766   unsigned int arg2 ;
40767
40768   arg1 = (Dali::PanGestureDetector *)jarg1;
40769   arg2 = (unsigned int)jarg2;
40770   {
40771     try {
40772       (arg1)->SetMaximumTouchesRequired(arg2);
40773     } catch (std::out_of_range& e) {
40774       {
40775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40776       };
40777     } catch (std::exception& e) {
40778       {
40779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40780       };
40781     } catch (Dali::DaliException e) {
40782       {
40783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40784       };
40785     } catch (...) {
40786       {
40787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40788       };
40789     }
40790   }
40791
40792 }
40793
40794
40795 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
40796   unsigned int jresult ;
40797   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40798   unsigned int result;
40799
40800   arg1 = (Dali::PanGestureDetector *)jarg1;
40801   {
40802     try {
40803       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMinimumTouchesRequired();
40804     } catch (std::out_of_range& e) {
40805       {
40806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40807       };
40808     } catch (std::exception& e) {
40809       {
40810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40811       };
40812     } catch (Dali::DaliException e) {
40813       {
40814         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40815       };
40816     } catch (...) {
40817       {
40818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40819       };
40820     }
40821   }
40822
40823   jresult = result;
40824   return jresult;
40825 }
40826
40827
40828 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
40829   unsigned int jresult ;
40830   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40831   unsigned int result;
40832
40833   arg1 = (Dali::PanGestureDetector *)jarg1;
40834   {
40835     try {
40836       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMaximumTouchesRequired();
40837     } catch (std::out_of_range& e) {
40838       {
40839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40840       };
40841     } catch (std::exception& e) {
40842       {
40843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40844       };
40845     } catch (Dali::DaliException e) {
40846       {
40847         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40848       };
40849     } catch (...) {
40850       {
40851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40852       };
40853     }
40854   }
40855
40856   jresult = result;
40857   return jresult;
40858 }
40859
40860
40861 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
40862   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40863   Dali::Radian arg2 ;
40864   Dali::Radian arg3 ;
40865   Dali::Radian *argp2 ;
40866   Dali::Radian *argp3 ;
40867
40868   arg1 = (Dali::PanGestureDetector *)jarg1;
40869   argp2 = (Dali::Radian *)jarg2;
40870   if (!argp2) {
40871     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40872     return ;
40873   }
40874   arg2 = *argp2;
40875   argp3 = (Dali::Radian *)jarg3;
40876   if (!argp3) {
40877     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40878     return ;
40879   }
40880   arg3 = *argp3;
40881   {
40882     try {
40883       (arg1)->AddAngle(arg2,arg3);
40884     } catch (std::out_of_range& e) {
40885       {
40886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40887       };
40888     } catch (std::exception& e) {
40889       {
40890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40891       };
40892     } catch (Dali::DaliException e) {
40893       {
40894         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40895       };
40896     } catch (...) {
40897       {
40898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40899       };
40900     }
40901   }
40902
40903 }
40904
40905
40906 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_1(void * jarg1, void * jarg2) {
40907   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40908   Dali::Radian arg2 ;
40909   Dali::Radian *argp2 ;
40910
40911   arg1 = (Dali::PanGestureDetector *)jarg1;
40912   argp2 = (Dali::Radian *)jarg2;
40913   if (!argp2) {
40914     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40915     return ;
40916   }
40917   arg2 = *argp2;
40918   {
40919     try {
40920       (arg1)->AddAngle(arg2);
40921     } catch (std::out_of_range& e) {
40922       {
40923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40924       };
40925     } catch (std::exception& e) {
40926       {
40927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40928       };
40929     } catch (Dali::DaliException e) {
40930       {
40931         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40932       };
40933     } catch (...) {
40934       {
40935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40936       };
40937     }
40938   }
40939
40940 }
40941
40942
40943 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
40944   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40945   Dali::Radian arg2 ;
40946   Dali::Radian arg3 ;
40947   Dali::Radian *argp2 ;
40948   Dali::Radian *argp3 ;
40949
40950   arg1 = (Dali::PanGestureDetector *)jarg1;
40951   argp2 = (Dali::Radian *)jarg2;
40952   if (!argp2) {
40953     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40954     return ;
40955   }
40956   arg2 = *argp2;
40957   argp3 = (Dali::Radian *)jarg3;
40958   if (!argp3) {
40959     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40960     return ;
40961   }
40962   arg3 = *argp3;
40963   {
40964     try {
40965       (arg1)->AddDirection(arg2,arg3);
40966     } catch (std::out_of_range& e) {
40967       {
40968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40969       };
40970     } catch (std::exception& e) {
40971       {
40972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40973       };
40974     } catch (Dali::DaliException e) {
40975       {
40976         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40977       };
40978     } catch (...) {
40979       {
40980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40981       };
40982     }
40983   }
40984
40985 }
40986
40987
40988 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_1(void * jarg1, void * jarg2) {
40989   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40990   Dali::Radian arg2 ;
40991   Dali::Radian *argp2 ;
40992
40993   arg1 = (Dali::PanGestureDetector *)jarg1;
40994   argp2 = (Dali::Radian *)jarg2;
40995   if (!argp2) {
40996     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40997     return ;
40998   }
40999   arg2 = *argp2;
41000   {
41001     try {
41002       (arg1)->AddDirection(arg2);
41003     } catch (std::out_of_range& e) {
41004       {
41005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41006       };
41007     } catch (std::exception& e) {
41008       {
41009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41010       };
41011     } catch (Dali::DaliException e) {
41012       {
41013         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41014       };
41015     } catch (...) {
41016       {
41017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41018       };
41019     }
41020   }
41021
41022 }
41023
41024
41025 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngleCount(void * jarg1) {
41026   unsigned long jresult ;
41027   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41028   size_t result;
41029
41030   arg1 = (Dali::PanGestureDetector *)jarg1;
41031   {
41032     try {
41033       result = ((Dali::PanGestureDetector const *)arg1)->GetAngleCount();
41034     } catch (std::out_of_range& e) {
41035       {
41036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41037       };
41038     } catch (std::exception& e) {
41039       {
41040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41041       };
41042     } catch (Dali::DaliException e) {
41043       {
41044         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41045       };
41046     } catch (...) {
41047       {
41048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41049       };
41050     }
41051   }
41052
41053   jresult = (unsigned long)result;
41054   return jresult;
41055 }
41056
41057
41058 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngle(void * jarg1, unsigned long jarg2) {
41059   void * jresult ;
41060   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41061   size_t arg2 ;
41062   Dali::PanGestureDetector::AngleThresholdPair result;
41063
41064   arg1 = (Dali::PanGestureDetector *)jarg1;
41065   arg2 = (size_t)jarg2;
41066   {
41067     try {
41068       result = ((Dali::PanGestureDetector const *)arg1)->GetAngle(arg2);
41069     } catch (std::out_of_range& e) {
41070       {
41071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41072       };
41073     } catch (std::exception& e) {
41074       {
41075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41076       };
41077     } catch (Dali::DaliException e) {
41078       {
41079         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41080       };
41081     } catch (...) {
41082       {
41083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41084       };
41085     }
41086   }
41087
41088   jresult = new Dali::PanGestureDetector::AngleThresholdPair((const Dali::PanGestureDetector::AngleThresholdPair &)result);
41089   return jresult;
41090 }
41091
41092
41093 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_ClearAngles(void * jarg1) {
41094   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41095
41096   arg1 = (Dali::PanGestureDetector *)jarg1;
41097   {
41098     try {
41099       (arg1)->ClearAngles();
41100     } catch (std::out_of_range& e) {
41101       {
41102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41103       };
41104     } catch (std::exception& e) {
41105       {
41106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41107       };
41108     } catch (Dali::DaliException e) {
41109       {
41110         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41111       };
41112     } catch (...) {
41113       {
41114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41115       };
41116     }
41117   }
41118
41119 }
41120
41121
41122 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveAngle(void * jarg1, void * jarg2) {
41123   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41124   Dali::Radian arg2 ;
41125   Dali::Radian *argp2 ;
41126
41127   arg1 = (Dali::PanGestureDetector *)jarg1;
41128   argp2 = (Dali::Radian *)jarg2;
41129   if (!argp2) {
41130     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
41131     return ;
41132   }
41133   arg2 = *argp2;
41134   {
41135     try {
41136       (arg1)->RemoveAngle(arg2);
41137     } catch (std::out_of_range& e) {
41138       {
41139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41140       };
41141     } catch (std::exception& e) {
41142       {
41143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41144       };
41145     } catch (Dali::DaliException e) {
41146       {
41147         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41148       };
41149     } catch (...) {
41150       {
41151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41152       };
41153     }
41154   }
41155
41156 }
41157
41158
41159 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveDirection(void * jarg1, void * jarg2) {
41160   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41161   Dali::Radian arg2 ;
41162   Dali::Radian *argp2 ;
41163
41164   arg1 = (Dali::PanGestureDetector *)jarg1;
41165   argp2 = (Dali::Radian *)jarg2;
41166   if (!argp2) {
41167     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
41168     return ;
41169   }
41170   arg2 = *argp2;
41171   {
41172     try {
41173       (arg1)->RemoveDirection(arg2);
41174     } catch (std::out_of_range& e) {
41175       {
41176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41177       };
41178     } catch (std::exception& e) {
41179       {
41180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41181       };
41182     } catch (Dali::DaliException e) {
41183       {
41184         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41185       };
41186     } catch (...) {
41187       {
41188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41189       };
41190     }
41191   }
41192
41193 }
41194
41195
41196 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DetectedSignal(void * jarg1) {
41197   void * jresult ;
41198   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41199   Dali::PanGestureDetector::DetectedSignalType *result = 0 ;
41200
41201   arg1 = (Dali::PanGestureDetector *)jarg1;
41202   {
41203     try {
41204       result = (Dali::PanGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
41205     } catch (std::out_of_range& e) {
41206       {
41207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41208       };
41209     } catch (std::exception& e) {
41210       {
41211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41212       };
41213     } catch (Dali::DaliException e) {
41214       {
41215         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41216       };
41217     } catch (...) {
41218       {
41219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41220       };
41221     }
41222   }
41223
41224   jresult = (void *)result;
41225   return jresult;
41226 }
41227
41228
41229 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetPanGestureProperties(void * jarg1) {
41230   Dali::PanGesture *arg1 = 0 ;
41231
41232   arg1 = (Dali::PanGesture *)jarg1;
41233   if (!arg1) {
41234     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
41235     return ;
41236   }
41237   {
41238     try {
41239       Dali::PanGestureDetector::SetPanGestureProperties((Dali::PanGesture const &)*arg1);
41240     } catch (std::out_of_range& e) {
41241       {
41242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41243       };
41244     } catch (std::exception& e) {
41245       {
41246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41247       };
41248     } catch (Dali::DaliException e) {
41249       {
41250         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41251       };
41252     } catch (...) {
41253       {
41254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41255       };
41256     }
41257   }
41258
41259 }
41260
41261
41262 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_0() {
41263   void * jresult ;
41264   Dali::PanGesture *result = 0 ;
41265
41266   {
41267     try {
41268       result = (Dali::PanGesture *)new Dali::PanGesture();
41269     } catch (std::out_of_range& e) {
41270       {
41271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41272       };
41273     } catch (std::exception& e) {
41274       {
41275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41276       };
41277     } catch (Dali::DaliException e) {
41278       {
41279         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41280       };
41281     } catch (...) {
41282       {
41283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41284       };
41285     }
41286   }
41287
41288   jresult = (void *)result;
41289   return jresult;
41290 }
41291
41292
41293 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_1(int jarg1) {
41294   void * jresult ;
41295   Dali::Gesture::State arg1 ;
41296   Dali::PanGesture *result = 0 ;
41297
41298   arg1 = (Dali::Gesture::State)jarg1;
41299   {
41300     try {
41301       result = (Dali::PanGesture *)new Dali::PanGesture(arg1);
41302     } catch (std::out_of_range& e) {
41303       {
41304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41305       };
41306     } catch (std::exception& e) {
41307       {
41308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41309       };
41310     } catch (Dali::DaliException e) {
41311       {
41312         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41313       };
41314     } catch (...) {
41315       {
41316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41317       };
41318     }
41319   }
41320
41321   jresult = (void *)result;
41322   return jresult;
41323 }
41324
41325
41326 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_2(void * jarg1) {
41327   void * jresult ;
41328   Dali::PanGesture *arg1 = 0 ;
41329   Dali::PanGesture *result = 0 ;
41330
41331   arg1 = (Dali::PanGesture *)jarg1;
41332   if (!arg1) {
41333     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
41334     return 0;
41335   }
41336   {
41337     try {
41338       result = (Dali::PanGesture *)new Dali::PanGesture((Dali::PanGesture const &)*arg1);
41339     } catch (std::out_of_range& e) {
41340       {
41341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41342       };
41343     } catch (std::exception& e) {
41344       {
41345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41346       };
41347     } catch (Dali::DaliException e) {
41348       {
41349         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41350       };
41351     } catch (...) {
41352       {
41353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41354       };
41355     }
41356   }
41357
41358   jresult = (void *)result;
41359   return jresult;
41360 }
41361
41362
41363 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_Assign(void * jarg1, void * jarg2) {
41364   void * jresult ;
41365   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41366   Dali::PanGesture *arg2 = 0 ;
41367   Dali::PanGesture *result = 0 ;
41368
41369   arg1 = (Dali::PanGesture *)jarg1;
41370   arg2 = (Dali::PanGesture *)jarg2;
41371   if (!arg2) {
41372     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
41373     return 0;
41374   }
41375   {
41376     try {
41377       result = (Dali::PanGesture *) &(arg1)->operator =((Dali::PanGesture const &)*arg2);
41378     } catch (std::out_of_range& e) {
41379       {
41380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41381       };
41382     } catch (std::exception& e) {
41383       {
41384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41385       };
41386     } catch (Dali::DaliException e) {
41387       {
41388         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41389       };
41390     } catch (...) {
41391       {
41392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41393       };
41394     }
41395   }
41396
41397   jresult = (void *)result;
41398   return jresult;
41399 }
41400
41401
41402 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGesture(void * jarg1) {
41403   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41404
41405   arg1 = (Dali::PanGesture *)jarg1;
41406   {
41407     try {
41408       delete arg1;
41409     } catch (std::out_of_range& e) {
41410       {
41411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41412       };
41413     } catch (std::exception& e) {
41414       {
41415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41416       };
41417     } catch (Dali::DaliException e) {
41418       {
41419         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41420       };
41421     } catch (...) {
41422       {
41423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41424       };
41425     }
41426   }
41427
41428 }
41429
41430
41431 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_velocity_set(void * jarg1, void * jarg2) {
41432   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41433   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41434
41435   arg1 = (Dali::PanGesture *)jarg1;
41436   arg2 = (Dali::Vector2 *)jarg2;
41437   if (arg1) (arg1)->velocity = *arg2;
41438 }
41439
41440
41441 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_velocity_get(void * jarg1) {
41442   void * jresult ;
41443   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41444   Dali::Vector2 *result = 0 ;
41445
41446   arg1 = (Dali::PanGesture *)jarg1;
41447   result = (Dali::Vector2 *)& ((arg1)->velocity);
41448   jresult = (void *)result;
41449   return jresult;
41450 }
41451
41452
41453 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_displacement_set(void * jarg1, void * jarg2) {
41454   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41455   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41456
41457   arg1 = (Dali::PanGesture *)jarg1;
41458   arg2 = (Dali::Vector2 *)jarg2;
41459   if (arg1) (arg1)->displacement = *arg2;
41460 }
41461
41462
41463 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_displacement_get(void * jarg1) {
41464   void * jresult ;
41465   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41466   Dali::Vector2 *result = 0 ;
41467
41468   arg1 = (Dali::PanGesture *)jarg1;
41469   result = (Dali::Vector2 *)& ((arg1)->displacement);
41470   jresult = (void *)result;
41471   return jresult;
41472 }
41473
41474
41475 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_position_set(void * jarg1, void * jarg2) {
41476   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41477   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41478
41479   arg1 = (Dali::PanGesture *)jarg1;
41480   arg2 = (Dali::Vector2 *)jarg2;
41481   if (arg1) (arg1)->position = *arg2;
41482 }
41483
41484
41485 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_position_get(void * jarg1) {
41486   void * jresult ;
41487   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41488   Dali::Vector2 *result = 0 ;
41489
41490   arg1 = (Dali::PanGesture *)jarg1;
41491   result = (Dali::Vector2 *)& ((arg1)->position);
41492   jresult = (void *)result;
41493   return jresult;
41494 }
41495
41496
41497 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_set(void * jarg1, void * jarg2) {
41498   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41499   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41500
41501   arg1 = (Dali::PanGesture *)jarg1;
41502   arg2 = (Dali::Vector2 *)jarg2;
41503   if (arg1) (arg1)->screenVelocity = *arg2;
41504 }
41505
41506
41507 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_get(void * jarg1) {
41508   void * jresult ;
41509   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41510   Dali::Vector2 *result = 0 ;
41511
41512   arg1 = (Dali::PanGesture *)jarg1;
41513   result = (Dali::Vector2 *)& ((arg1)->screenVelocity);
41514   jresult = (void *)result;
41515   return jresult;
41516 }
41517
41518
41519 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_set(void * jarg1, void * jarg2) {
41520   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41521   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41522
41523   arg1 = (Dali::PanGesture *)jarg1;
41524   arg2 = (Dali::Vector2 *)jarg2;
41525   if (arg1) (arg1)->screenDisplacement = *arg2;
41526 }
41527
41528
41529 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_get(void * jarg1) {
41530   void * jresult ;
41531   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41532   Dali::Vector2 *result = 0 ;
41533
41534   arg1 = (Dali::PanGesture *)jarg1;
41535   result = (Dali::Vector2 *)& ((arg1)->screenDisplacement);
41536   jresult = (void *)result;
41537   return jresult;
41538 }
41539
41540
41541 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_set(void * jarg1, void * jarg2) {
41542   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41543   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41544
41545   arg1 = (Dali::PanGesture *)jarg1;
41546   arg2 = (Dali::Vector2 *)jarg2;
41547   if (arg1) (arg1)->screenPosition = *arg2;
41548 }
41549
41550
41551 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_get(void * jarg1) {
41552   void * jresult ;
41553   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41554   Dali::Vector2 *result = 0 ;
41555
41556   arg1 = (Dali::PanGesture *)jarg1;
41557   result = (Dali::Vector2 *)& ((arg1)->screenPosition);
41558   jresult = (void *)result;
41559   return jresult;
41560 }
41561
41562
41563 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
41564   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41565   unsigned int arg2 ;
41566
41567   arg1 = (Dali::PanGesture *)jarg1;
41568   arg2 = (unsigned int)jarg2;
41569   if (arg1) (arg1)->numberOfTouches = arg2;
41570 }
41571
41572
41573 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_get(void * jarg1) {
41574   unsigned int jresult ;
41575   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41576   unsigned int result;
41577
41578   arg1 = (Dali::PanGesture *)jarg1;
41579   result = (unsigned int) ((arg1)->numberOfTouches);
41580   jresult = result;
41581   return jresult;
41582 }
41583
41584
41585 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetSpeed(void * jarg1) {
41586   float jresult ;
41587   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41588   float result;
41589
41590   arg1 = (Dali::PanGesture *)jarg1;
41591   {
41592     try {
41593       result = (float)((Dali::PanGesture const *)arg1)->GetSpeed();
41594     } catch (std::out_of_range& e) {
41595       {
41596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41597       };
41598     } catch (std::exception& e) {
41599       {
41600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41601       };
41602     } catch (Dali::DaliException e) {
41603       {
41604         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41605       };
41606     } catch (...) {
41607       {
41608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41609       };
41610     }
41611   }
41612
41613   jresult = result;
41614   return jresult;
41615 }
41616
41617
41618 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetDistance(void * jarg1) {
41619   float jresult ;
41620   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41621   float result;
41622
41623   arg1 = (Dali::PanGesture *)jarg1;
41624   {
41625     try {
41626       result = (float)((Dali::PanGesture const *)arg1)->GetDistance();
41627     } catch (std::out_of_range& e) {
41628       {
41629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41630       };
41631     } catch (std::exception& e) {
41632       {
41633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41634       };
41635     } catch (Dali::DaliException e) {
41636       {
41637         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41638       };
41639     } catch (...) {
41640       {
41641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41642       };
41643     }
41644   }
41645
41646   jresult = result;
41647   return jresult;
41648 }
41649
41650
41651 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenSpeed(void * jarg1) {
41652   float jresult ;
41653   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41654   float result;
41655
41656   arg1 = (Dali::PanGesture *)jarg1;
41657   {
41658     try {
41659       result = (float)((Dali::PanGesture const *)arg1)->GetScreenSpeed();
41660     } catch (std::out_of_range& e) {
41661       {
41662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41663       };
41664     } catch (std::exception& e) {
41665       {
41666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41667       };
41668     } catch (Dali::DaliException e) {
41669       {
41670         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41671       };
41672     } catch (...) {
41673       {
41674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41675       };
41676     }
41677   }
41678
41679   jresult = result;
41680   return jresult;
41681 }
41682
41683
41684 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenDistance(void * jarg1) {
41685   float jresult ;
41686   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41687   float result;
41688
41689   arg1 = (Dali::PanGesture *)jarg1;
41690   {
41691     try {
41692       result = (float)((Dali::PanGesture const *)arg1)->GetScreenDistance();
41693     } catch (std::out_of_range& e) {
41694       {
41695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41696       };
41697     } catch (std::exception& e) {
41698       {
41699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41700       };
41701     } catch (Dali::DaliException e) {
41702       {
41703         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41704       };
41705     } catch (...) {
41706       {
41707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41708       };
41709     }
41710   }
41711
41712   jresult = result;
41713   return jresult;
41714 }
41715
41716
41717 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_0() {
41718   void * jresult ;
41719   Dali::PinchGestureDetector *result = 0 ;
41720
41721   {
41722     try {
41723       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector();
41724     } catch (std::out_of_range& e) {
41725       {
41726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41727       };
41728     } catch (std::exception& e) {
41729       {
41730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41731       };
41732     } catch (Dali::DaliException e) {
41733       {
41734         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41735       };
41736     } catch (...) {
41737       {
41738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41739       };
41740     }
41741   }
41742
41743   jresult = (void *)result;
41744   return jresult;
41745 }
41746
41747
41748 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_New() {
41749   void * jresult ;
41750   Dali::PinchGestureDetector result;
41751
41752   {
41753     try {
41754       result = Dali::PinchGestureDetector::New();
41755     } catch (std::out_of_range& e) {
41756       {
41757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41758       };
41759     } catch (std::exception& e) {
41760       {
41761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41762       };
41763     } catch (Dali::DaliException e) {
41764       {
41765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41766       };
41767     } catch (...) {
41768       {
41769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41770       };
41771     }
41772   }
41773
41774   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
41775   return jresult;
41776 }
41777
41778
41779 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DownCast(void * jarg1) {
41780   void * jresult ;
41781   Dali::BaseHandle arg1 ;
41782   Dali::BaseHandle *argp1 ;
41783   Dali::PinchGestureDetector result;
41784
41785   argp1 = (Dali::BaseHandle *)jarg1;
41786   if (!argp1) {
41787     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41788     return 0;
41789   }
41790   arg1 = *argp1;
41791   {
41792     try {
41793       result = Dali::PinchGestureDetector::DownCast(arg1);
41794     } catch (std::out_of_range& e) {
41795       {
41796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41797       };
41798     } catch (std::exception& e) {
41799       {
41800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41801       };
41802     } catch (Dali::DaliException e) {
41803       {
41804         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41805       };
41806     } catch (...) {
41807       {
41808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41809       };
41810     }
41811   }
41812
41813   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
41814   return jresult;
41815 }
41816
41817
41818 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetector(void * jarg1) {
41819   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
41820
41821   arg1 = (Dali::PinchGestureDetector *)jarg1;
41822   {
41823     try {
41824       delete arg1;
41825     } catch (std::out_of_range& e) {
41826       {
41827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41828       };
41829     } catch (std::exception& e) {
41830       {
41831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41832       };
41833     } catch (Dali::DaliException e) {
41834       {
41835         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41836       };
41837     } catch (...) {
41838       {
41839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41840       };
41841     }
41842   }
41843
41844 }
41845
41846
41847 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_1(void * jarg1) {
41848   void * jresult ;
41849   Dali::PinchGestureDetector *arg1 = 0 ;
41850   Dali::PinchGestureDetector *result = 0 ;
41851
41852   arg1 = (Dali::PinchGestureDetector *)jarg1;
41853   if (!arg1) {
41854     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
41855     return 0;
41856   }
41857   {
41858     try {
41859       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector((Dali::PinchGestureDetector const &)*arg1);
41860     } catch (std::out_of_range& e) {
41861       {
41862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41863       };
41864     } catch (std::exception& e) {
41865       {
41866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41867       };
41868     } catch (Dali::DaliException e) {
41869       {
41870         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41871       };
41872     } catch (...) {
41873       {
41874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41875       };
41876     }
41877   }
41878
41879   jresult = (void *)result;
41880   return jresult;
41881 }
41882
41883
41884 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_Assign(void * jarg1, void * jarg2) {
41885   void * jresult ;
41886   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
41887   Dali::PinchGestureDetector *arg2 = 0 ;
41888   Dali::PinchGestureDetector *result = 0 ;
41889
41890   arg1 = (Dali::PinchGestureDetector *)jarg1;
41891   arg2 = (Dali::PinchGestureDetector *)jarg2;
41892   if (!arg2) {
41893     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
41894     return 0;
41895   }
41896   {
41897     try {
41898       result = (Dali::PinchGestureDetector *) &(arg1)->operator =((Dali::PinchGestureDetector const &)*arg2);
41899     } catch (std::out_of_range& e) {
41900       {
41901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41902       };
41903     } catch (std::exception& e) {
41904       {
41905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41906       };
41907     } catch (Dali::DaliException e) {
41908       {
41909         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41910       };
41911     } catch (...) {
41912       {
41913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41914       };
41915     }
41916   }
41917
41918   jresult = (void *)result;
41919   return jresult;
41920 }
41921
41922
41923 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DetectedSignal(void * jarg1) {
41924   void * jresult ;
41925   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
41926   Dali::PinchGestureDetector::DetectedSignalType *result = 0 ;
41927
41928   arg1 = (Dali::PinchGestureDetector *)jarg1;
41929   {
41930     try {
41931       result = (Dali::PinchGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
41932     } catch (std::out_of_range& e) {
41933       {
41934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41935       };
41936     } catch (std::exception& e) {
41937       {
41938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41939       };
41940     } catch (Dali::DaliException e) {
41941       {
41942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41943       };
41944     } catch (...) {
41945       {
41946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41947       };
41948     }
41949   }
41950
41951   jresult = (void *)result;
41952   return jresult;
41953 }
41954
41955
41956 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_0(int jarg1) {
41957   void * jresult ;
41958   Dali::Gesture::State arg1 ;
41959   Dali::PinchGesture *result = 0 ;
41960
41961   arg1 = (Dali::Gesture::State)jarg1;
41962   {
41963     try {
41964       result = (Dali::PinchGesture *)new Dali::PinchGesture(arg1);
41965     } catch (std::out_of_range& e) {
41966       {
41967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41968       };
41969     } catch (std::exception& e) {
41970       {
41971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41972       };
41973     } catch (Dali::DaliException e) {
41974       {
41975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41976       };
41977     } catch (...) {
41978       {
41979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41980       };
41981     }
41982   }
41983
41984   jresult = (void *)result;
41985   return jresult;
41986 }
41987
41988
41989 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_1(void * jarg1) {
41990   void * jresult ;
41991   Dali::PinchGesture *arg1 = 0 ;
41992   Dali::PinchGesture *result = 0 ;
41993
41994   arg1 = (Dali::PinchGesture *)jarg1;
41995   if (!arg1) {
41996     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
41997     return 0;
41998   }
41999   {
42000     try {
42001       result = (Dali::PinchGesture *)new Dali::PinchGesture((Dali::PinchGesture const &)*arg1);
42002     } catch (std::out_of_range& e) {
42003       {
42004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42005       };
42006     } catch (std::exception& e) {
42007       {
42008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42009       };
42010     } catch (Dali::DaliException e) {
42011       {
42012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42013       };
42014     } catch (...) {
42015       {
42016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42017       };
42018     }
42019   }
42020
42021   jresult = (void *)result;
42022   return jresult;
42023 }
42024
42025
42026 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_Assign(void * jarg1, void * jarg2) {
42027   void * jresult ;
42028   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42029   Dali::PinchGesture *arg2 = 0 ;
42030   Dali::PinchGesture *result = 0 ;
42031
42032   arg1 = (Dali::PinchGesture *)jarg1;
42033   arg2 = (Dali::PinchGesture *)jarg2;
42034   if (!arg2) {
42035     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
42036     return 0;
42037   }
42038   {
42039     try {
42040       result = (Dali::PinchGesture *) &(arg1)->operator =((Dali::PinchGesture const &)*arg2);
42041     } catch (std::out_of_range& e) {
42042       {
42043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42044       };
42045     } catch (std::exception& e) {
42046       {
42047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42048       };
42049     } catch (Dali::DaliException e) {
42050       {
42051         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42052       };
42053     } catch (...) {
42054       {
42055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42056       };
42057     }
42058   }
42059
42060   jresult = (void *)result;
42061   return jresult;
42062 }
42063
42064
42065 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGesture(void * jarg1) {
42066   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42067
42068   arg1 = (Dali::PinchGesture *)jarg1;
42069   {
42070     try {
42071       delete arg1;
42072     } catch (std::out_of_range& e) {
42073       {
42074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42075       };
42076     } catch (std::exception& e) {
42077       {
42078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42079       };
42080     } catch (Dali::DaliException e) {
42081       {
42082         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42083       };
42084     } catch (...) {
42085       {
42086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42087       };
42088     }
42089   }
42090
42091 }
42092
42093
42094 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_scale_set(void * jarg1, float jarg2) {
42095   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42096   float arg2 ;
42097
42098   arg1 = (Dali::PinchGesture *)jarg1;
42099   arg2 = (float)jarg2;
42100   if (arg1) (arg1)->scale = arg2;
42101 }
42102
42103
42104 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_scale_get(void * jarg1) {
42105   float jresult ;
42106   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42107   float result;
42108
42109   arg1 = (Dali::PinchGesture *)jarg1;
42110   result = (float) ((arg1)->scale);
42111   jresult = result;
42112   return jresult;
42113 }
42114
42115
42116 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_speed_set(void * jarg1, float jarg2) {
42117   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42118   float arg2 ;
42119
42120   arg1 = (Dali::PinchGesture *)jarg1;
42121   arg2 = (float)jarg2;
42122   if (arg1) (arg1)->speed = arg2;
42123 }
42124
42125
42126 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_speed_get(void * jarg1) {
42127   float jresult ;
42128   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42129   float result;
42130
42131   arg1 = (Dali::PinchGesture *)jarg1;
42132   result = (float) ((arg1)->speed);
42133   jresult = result;
42134   return jresult;
42135 }
42136
42137
42138 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_set(void * jarg1, void * jarg2) {
42139   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42140   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42141
42142   arg1 = (Dali::PinchGesture *)jarg1;
42143   arg2 = (Dali::Vector2 *)jarg2;
42144   if (arg1) (arg1)->screenCenterPoint = *arg2;
42145 }
42146
42147
42148 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_get(void * jarg1) {
42149   void * jresult ;
42150   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42151   Dali::Vector2 *result = 0 ;
42152
42153   arg1 = (Dali::PinchGesture *)jarg1;
42154   result = (Dali::Vector2 *)& ((arg1)->screenCenterPoint);
42155   jresult = (void *)result;
42156   return jresult;
42157 }
42158
42159
42160 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_set(void * jarg1, void * jarg2) {
42161   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42162   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42163
42164   arg1 = (Dali::PinchGesture *)jarg1;
42165   arg2 = (Dali::Vector2 *)jarg2;
42166   if (arg1) (arg1)->localCenterPoint = *arg2;
42167 }
42168
42169
42170 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_get(void * jarg1) {
42171   void * jresult ;
42172   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42173   Dali::Vector2 *result = 0 ;
42174
42175   arg1 = (Dali::PinchGesture *)jarg1;
42176   result = (Dali::Vector2 *)& ((arg1)->localCenterPoint);
42177   jresult = (void *)result;
42178   return jresult;
42179 }
42180
42181
42182 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_0() {
42183   void * jresult ;
42184   Dali::TapGestureDetector *result = 0 ;
42185
42186   {
42187     try {
42188       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector();
42189     } catch (std::out_of_range& e) {
42190       {
42191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42192       };
42193     } catch (std::exception& e) {
42194       {
42195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42196       };
42197     } catch (Dali::DaliException e) {
42198       {
42199         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42200       };
42201     } catch (...) {
42202       {
42203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42204       };
42205     }
42206   }
42207
42208   jresult = (void *)result;
42209   return jresult;
42210 }
42211
42212
42213 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_0() {
42214   void * jresult ;
42215   Dali::TapGestureDetector result;
42216
42217   {
42218     try {
42219       result = Dali::TapGestureDetector::New();
42220     } catch (std::out_of_range& e) {
42221       {
42222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42223       };
42224     } catch (std::exception& e) {
42225       {
42226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42227       };
42228     } catch (Dali::DaliException e) {
42229       {
42230         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42231       };
42232     } catch (...) {
42233       {
42234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42235       };
42236     }
42237   }
42238
42239   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
42240   return jresult;
42241 }
42242
42243
42244 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_1(unsigned int jarg1) {
42245   void * jresult ;
42246   unsigned int arg1 ;
42247   Dali::TapGestureDetector result;
42248
42249   arg1 = (unsigned int)jarg1;
42250   {
42251     try {
42252       result = Dali::TapGestureDetector::New(arg1);
42253     } catch (std::out_of_range& e) {
42254       {
42255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42256       };
42257     } catch (std::exception& e) {
42258       {
42259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42260       };
42261     } catch (Dali::DaliException e) {
42262       {
42263         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42264       };
42265     } catch (...) {
42266       {
42267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42268       };
42269     }
42270   }
42271
42272   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
42273   return jresult;
42274 }
42275
42276
42277 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DownCast(void * jarg1) {
42278   void * jresult ;
42279   Dali::BaseHandle arg1 ;
42280   Dali::BaseHandle *argp1 ;
42281   Dali::TapGestureDetector result;
42282
42283   argp1 = (Dali::BaseHandle *)jarg1;
42284   if (!argp1) {
42285     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
42286     return 0;
42287   }
42288   arg1 = *argp1;
42289   {
42290     try {
42291       result = Dali::TapGestureDetector::DownCast(arg1);
42292     } catch (std::out_of_range& e) {
42293       {
42294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42295       };
42296     } catch (std::exception& e) {
42297       {
42298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42299       };
42300     } catch (Dali::DaliException e) {
42301       {
42302         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42303       };
42304     } catch (...) {
42305       {
42306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42307       };
42308     }
42309   }
42310
42311   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
42312   return jresult;
42313 }
42314
42315
42316 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetector(void * jarg1) {
42317   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42318
42319   arg1 = (Dali::TapGestureDetector *)jarg1;
42320   {
42321     try {
42322       delete arg1;
42323     } catch (std::out_of_range& e) {
42324       {
42325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42326       };
42327     } catch (std::exception& e) {
42328       {
42329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42330       };
42331     } catch (Dali::DaliException e) {
42332       {
42333         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42334       };
42335     } catch (...) {
42336       {
42337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42338       };
42339     }
42340   }
42341
42342 }
42343
42344
42345 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_1(void * jarg1) {
42346   void * jresult ;
42347   Dali::TapGestureDetector *arg1 = 0 ;
42348   Dali::TapGestureDetector *result = 0 ;
42349
42350   arg1 = (Dali::TapGestureDetector *)jarg1;
42351   if (!arg1) {
42352     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
42353     return 0;
42354   }
42355   {
42356     try {
42357       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector((Dali::TapGestureDetector const &)*arg1);
42358     } catch (std::out_of_range& e) {
42359       {
42360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42361       };
42362     } catch (std::exception& e) {
42363       {
42364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42365       };
42366     } catch (Dali::DaliException e) {
42367       {
42368         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42369       };
42370     } catch (...) {
42371       {
42372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42373       };
42374     }
42375   }
42376
42377   jresult = (void *)result;
42378   return jresult;
42379 }
42380
42381
42382 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_Assign(void * jarg1, void * jarg2) {
42383   void * jresult ;
42384   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42385   Dali::TapGestureDetector *arg2 = 0 ;
42386   Dali::TapGestureDetector *result = 0 ;
42387
42388   arg1 = (Dali::TapGestureDetector *)jarg1;
42389   arg2 = (Dali::TapGestureDetector *)jarg2;
42390   if (!arg2) {
42391     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
42392     return 0;
42393   }
42394   {
42395     try {
42396       result = (Dali::TapGestureDetector *) &(arg1)->operator =((Dali::TapGestureDetector const &)*arg2);
42397     } catch (std::out_of_range& e) {
42398       {
42399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42400       };
42401     } catch (std::exception& e) {
42402       {
42403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42404       };
42405     } catch (Dali::DaliException e) {
42406       {
42407         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42408       };
42409     } catch (...) {
42410       {
42411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42412       };
42413     }
42414   }
42415
42416   jresult = (void *)result;
42417   return jresult;
42418 }
42419
42420
42421 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMinimumTapsRequired(void * jarg1, unsigned int jarg2) {
42422   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42423   unsigned int arg2 ;
42424
42425   arg1 = (Dali::TapGestureDetector *)jarg1;
42426   arg2 = (unsigned int)jarg2;
42427   {
42428     try {
42429       (arg1)->SetMinimumTapsRequired(arg2);
42430     } catch (std::out_of_range& e) {
42431       {
42432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42433       };
42434     } catch (std::exception& e) {
42435       {
42436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42437       };
42438     } catch (Dali::DaliException e) {
42439       {
42440         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42441       };
42442     } catch (...) {
42443       {
42444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42445       };
42446     }
42447   }
42448
42449 }
42450
42451
42452 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMaximumTapsRequired(void * jarg1, unsigned int jarg2) {
42453   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42454   unsigned int arg2 ;
42455
42456   arg1 = (Dali::TapGestureDetector *)jarg1;
42457   arg2 = (unsigned int)jarg2;
42458   {
42459     try {
42460       (arg1)->SetMaximumTapsRequired(arg2);
42461     } catch (std::out_of_range& e) {
42462       {
42463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42464       };
42465     } catch (std::exception& e) {
42466       {
42467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42468       };
42469     } catch (Dali::DaliException e) {
42470       {
42471         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42472       };
42473     } catch (...) {
42474       {
42475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42476       };
42477     }
42478   }
42479
42480 }
42481
42482
42483 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMinimumTapsRequired(void * jarg1) {
42484   unsigned int jresult ;
42485   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42486   unsigned int result;
42487
42488   arg1 = (Dali::TapGestureDetector *)jarg1;
42489   {
42490     try {
42491       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMinimumTapsRequired();
42492     } catch (std::out_of_range& e) {
42493       {
42494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42495       };
42496     } catch (std::exception& e) {
42497       {
42498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42499       };
42500     } catch (Dali::DaliException e) {
42501       {
42502         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42503       };
42504     } catch (...) {
42505       {
42506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42507       };
42508     }
42509   }
42510
42511   jresult = result;
42512   return jresult;
42513 }
42514
42515
42516 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMaximumTapsRequired(void * jarg1) {
42517   unsigned int jresult ;
42518   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42519   unsigned int result;
42520
42521   arg1 = (Dali::TapGestureDetector *)jarg1;
42522   {
42523     try {
42524       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMaximumTapsRequired();
42525     } catch (std::out_of_range& e) {
42526       {
42527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42528       };
42529     } catch (std::exception& e) {
42530       {
42531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42532       };
42533     } catch (Dali::DaliException e) {
42534       {
42535         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42536       };
42537     } catch (...) {
42538       {
42539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42540       };
42541     }
42542   }
42543
42544   jresult = result;
42545   return jresult;
42546 }
42547
42548
42549 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DetectedSignal(void * jarg1) {
42550   void * jresult ;
42551   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42552   Dali::TapGestureDetector::DetectedSignalType *result = 0 ;
42553
42554   arg1 = (Dali::TapGestureDetector *)jarg1;
42555   {
42556     try {
42557       result = (Dali::TapGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
42558     } catch (std::out_of_range& e) {
42559       {
42560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42561       };
42562     } catch (std::exception& e) {
42563       {
42564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42565       };
42566     } catch (Dali::DaliException e) {
42567       {
42568         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42569       };
42570     } catch (...) {
42571       {
42572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42573       };
42574     }
42575   }
42576
42577   jresult = (void *)result;
42578   return jresult;
42579 }
42580
42581
42582 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_0() {
42583   void * jresult ;
42584   Dali::TapGesture *result = 0 ;
42585
42586   {
42587     try {
42588       result = (Dali::TapGesture *)new Dali::TapGesture();
42589     } catch (std::out_of_range& e) {
42590       {
42591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42592       };
42593     } catch (std::exception& e) {
42594       {
42595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42596       };
42597     } catch (Dali::DaliException e) {
42598       {
42599         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42600       };
42601     } catch (...) {
42602       {
42603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42604       };
42605     }
42606   }
42607
42608   jresult = (void *)result;
42609   return jresult;
42610 }
42611
42612
42613 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_1(void * jarg1) {
42614   void * jresult ;
42615   Dali::TapGesture *arg1 = 0 ;
42616   Dali::TapGesture *result = 0 ;
42617
42618   arg1 = (Dali::TapGesture *)jarg1;
42619   if (!arg1) {
42620     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
42621     return 0;
42622   }
42623   {
42624     try {
42625       result = (Dali::TapGesture *)new Dali::TapGesture((Dali::TapGesture const &)*arg1);
42626     } catch (std::out_of_range& e) {
42627       {
42628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42629       };
42630     } catch (std::exception& e) {
42631       {
42632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42633       };
42634     } catch (Dali::DaliException e) {
42635       {
42636         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42637       };
42638     } catch (...) {
42639       {
42640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42641       };
42642     }
42643   }
42644
42645   jresult = (void *)result;
42646   return jresult;
42647 }
42648
42649
42650 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_Assign(void * jarg1, void * jarg2) {
42651   void * jresult ;
42652   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42653   Dali::TapGesture *arg2 = 0 ;
42654   Dali::TapGesture *result = 0 ;
42655
42656   arg1 = (Dali::TapGesture *)jarg1;
42657   arg2 = (Dali::TapGesture *)jarg2;
42658   if (!arg2) {
42659     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
42660     return 0;
42661   }
42662   {
42663     try {
42664       result = (Dali::TapGesture *) &(arg1)->operator =((Dali::TapGesture const &)*arg2);
42665     } catch (std::out_of_range& e) {
42666       {
42667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42668       };
42669     } catch (std::exception& e) {
42670       {
42671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42672       };
42673     } catch (Dali::DaliException e) {
42674       {
42675         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42676       };
42677     } catch (...) {
42678       {
42679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42680       };
42681     }
42682   }
42683
42684   jresult = (void *)result;
42685   return jresult;
42686 }
42687
42688
42689 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGesture(void * jarg1) {
42690   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42691
42692   arg1 = (Dali::TapGesture *)jarg1;
42693   {
42694     try {
42695       delete arg1;
42696     } catch (std::out_of_range& e) {
42697       {
42698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42699       };
42700     } catch (std::exception& e) {
42701       {
42702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42703       };
42704     } catch (Dali::DaliException e) {
42705       {
42706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42707       };
42708     } catch (...) {
42709       {
42710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42711       };
42712     }
42713   }
42714
42715 }
42716
42717
42718 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_set(void * jarg1, unsigned int jarg2) {
42719   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42720   unsigned int arg2 ;
42721
42722   arg1 = (Dali::TapGesture *)jarg1;
42723   arg2 = (unsigned int)jarg2;
42724   if (arg1) (arg1)->numberOfTaps = arg2;
42725 }
42726
42727
42728 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_get(void * jarg1) {
42729   unsigned int jresult ;
42730   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42731   unsigned int result;
42732
42733   arg1 = (Dali::TapGesture *)jarg1;
42734   result = (unsigned int) ((arg1)->numberOfTaps);
42735   jresult = result;
42736   return jresult;
42737 }
42738
42739
42740 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
42741   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42742   unsigned int arg2 ;
42743
42744   arg1 = (Dali::TapGesture *)jarg1;
42745   arg2 = (unsigned int)jarg2;
42746   if (arg1) (arg1)->numberOfTouches = arg2;
42747 }
42748
42749
42750 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_get(void * jarg1) {
42751   unsigned int jresult ;
42752   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42753   unsigned int result;
42754
42755   arg1 = (Dali::TapGesture *)jarg1;
42756   result = (unsigned int) ((arg1)->numberOfTouches);
42757   jresult = result;
42758   return jresult;
42759 }
42760
42761
42762 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_set(void * jarg1, void * jarg2) {
42763   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42764   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42765
42766   arg1 = (Dali::TapGesture *)jarg1;
42767   arg2 = (Dali::Vector2 *)jarg2;
42768   if (arg1) (arg1)->screenPoint = *arg2;
42769 }
42770
42771
42772 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_get(void * jarg1) {
42773   void * jresult ;
42774   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42775   Dali::Vector2 *result = 0 ;
42776
42777   arg1 = (Dali::TapGesture *)jarg1;
42778   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
42779   jresult = (void *)result;
42780   return jresult;
42781 }
42782
42783
42784 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_set(void * jarg1, void * jarg2) {
42785   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42786   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42787
42788   arg1 = (Dali::TapGesture *)jarg1;
42789   arg2 = (Dali::Vector2 *)jarg2;
42790   if (arg1) (arg1)->localPoint = *arg2;
42791 }
42792
42793
42794 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_get(void * jarg1) {
42795   void * jresult ;
42796   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42797   Dali::Vector2 *result = 0 ;
42798
42799   arg1 = (Dali::TapGesture *)jarg1;
42800   result = (Dali::Vector2 *)& ((arg1)->localPoint);
42801   jresult = (void *)result;
42802   return jresult;
42803 }
42804
42805
42806 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_0() {
42807   void * jresult ;
42808   Dali::AlphaFunction *result = 0 ;
42809
42810   {
42811     try {
42812       result = (Dali::AlphaFunction *)new Dali::AlphaFunction();
42813     } catch (std::out_of_range& e) {
42814       {
42815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42816       };
42817     } catch (std::exception& e) {
42818       {
42819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42820       };
42821     } catch (Dali::DaliException e) {
42822       {
42823         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42824       };
42825     } catch (...) {
42826       {
42827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42828       };
42829     }
42830   }
42831
42832   jresult = (void *)result;
42833   return jresult;
42834 }
42835
42836
42837 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_1(int jarg1) {
42838   void * jresult ;
42839   Dali::AlphaFunction::BuiltinFunction arg1 ;
42840   Dali::AlphaFunction *result = 0 ;
42841
42842   arg1 = (Dali::AlphaFunction::BuiltinFunction)jarg1;
42843   {
42844     try {
42845       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
42846     } catch (std::out_of_range& e) {
42847       {
42848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42849       };
42850     } catch (std::exception& e) {
42851       {
42852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42853       };
42854     } catch (Dali::DaliException e) {
42855       {
42856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42857       };
42858     } catch (...) {
42859       {
42860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42861       };
42862     }
42863   }
42864
42865   jresult = (void *)result;
42866   return jresult;
42867 }
42868
42869
42870 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_2(void * jarg1) {
42871   void * jresult ;
42872   Dali::AlphaFunctionPrototype arg1 = (Dali::AlphaFunctionPrototype) 0 ;
42873   Dali::AlphaFunction *result = 0 ;
42874
42875   arg1 = (Dali::AlphaFunctionPrototype)jarg1;
42876   {
42877     try {
42878       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
42879     } catch (std::out_of_range& e) {
42880       {
42881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42882       };
42883     } catch (std::exception& e) {
42884       {
42885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42886       };
42887     } catch (Dali::DaliException e) {
42888       {
42889         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42890       };
42891     } catch (...) {
42892       {
42893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42894       };
42895     }
42896   }
42897
42898   jresult = (void *)result;
42899   return jresult;
42900 }
42901
42902
42903 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_3(void * jarg1, void * jarg2) {
42904   void * jresult ;
42905   Dali::Vector2 *arg1 = 0 ;
42906   Dali::Vector2 *arg2 = 0 ;
42907   Dali::AlphaFunction *result = 0 ;
42908
42909   arg1 = (Dali::Vector2 *)jarg1;
42910   if (!arg1) {
42911     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
42912     return 0;
42913   }
42914   arg2 = (Dali::Vector2 *)jarg2;
42915   if (!arg2) {
42916     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
42917     return 0;
42918   }
42919   {
42920     try {
42921       result = (Dali::AlphaFunction *)new Dali::AlphaFunction((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
42922     } catch (std::out_of_range& e) {
42923       {
42924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42925       };
42926     } catch (std::exception& e) {
42927       {
42928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42929       };
42930     } catch (Dali::DaliException e) {
42931       {
42932         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42933       };
42934     } catch (...) {
42935       {
42936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42937       };
42938     }
42939   }
42940
42941   jresult = (void *)result;
42942   return jresult;
42943 }
42944
42945
42946 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBezierControlPoints(void * jarg1) {
42947   void * jresult ;
42948   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
42949   Dali::Vector4 result;
42950
42951   arg1 = (Dali::AlphaFunction *)jarg1;
42952   {
42953     try {
42954       result = ((Dali::AlphaFunction const *)arg1)->GetBezierControlPoints();
42955     } catch (std::out_of_range& e) {
42956       {
42957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42958       };
42959     } catch (std::exception& e) {
42960       {
42961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42962       };
42963     } catch (Dali::DaliException e) {
42964       {
42965         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42966       };
42967     } catch (...) {
42968       {
42969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42970       };
42971     }
42972   }
42973
42974   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
42975   return jresult;
42976 }
42977
42978
42979 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetCustomFunction(void * jarg1) {
42980   void * jresult ;
42981   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
42982   Dali::AlphaFunctionPrototype result;
42983
42984   arg1 = (Dali::AlphaFunction *)jarg1;
42985   {
42986     try {
42987       result = (Dali::AlphaFunctionPrototype)((Dali::AlphaFunction const *)arg1)->GetCustomFunction();
42988     } catch (std::out_of_range& e) {
42989       {
42990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42991       };
42992     } catch (std::exception& e) {
42993       {
42994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42995       };
42996     } catch (Dali::DaliException e) {
42997       {
42998         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42999       };
43000     } catch (...) {
43001       {
43002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43003       };
43004     }
43005   }
43006
43007   jresult = (void *)result;
43008   return jresult;
43009 }
43010
43011
43012 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBuiltinFunction(void * jarg1) {
43013   int jresult ;
43014   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
43015   Dali::AlphaFunction::BuiltinFunction result;
43016
43017   arg1 = (Dali::AlphaFunction *)jarg1;
43018   {
43019     try {
43020       result = (Dali::AlphaFunction::BuiltinFunction)((Dali::AlphaFunction const *)arg1)->GetBuiltinFunction();
43021     } catch (std::out_of_range& e) {
43022       {
43023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43024       };
43025     } catch (std::exception& e) {
43026       {
43027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43028       };
43029     } catch (Dali::DaliException e) {
43030       {
43031         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43032       };
43033     } catch (...) {
43034       {
43035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43036       };
43037     }
43038   }
43039
43040   jresult = (int)result;
43041   return jresult;
43042 }
43043
43044
43045 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetMode(void * jarg1) {
43046   int jresult ;
43047   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
43048   Dali::AlphaFunction::Mode result;
43049
43050   arg1 = (Dali::AlphaFunction *)jarg1;
43051   {
43052     try {
43053       result = (Dali::AlphaFunction::Mode)((Dali::AlphaFunction const *)arg1)->GetMode();
43054     } catch (std::out_of_range& e) {
43055       {
43056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43057       };
43058     } catch (std::exception& e) {
43059       {
43060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43061       };
43062     } catch (Dali::DaliException e) {
43063       {
43064         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43065       };
43066     } catch (...) {
43067       {
43068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43069       };
43070     }
43071   }
43072
43073   jresult = (int)result;
43074   return jresult;
43075 }
43076
43077
43078 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AlphaFunction(void * jarg1) {
43079   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
43080
43081   arg1 = (Dali::AlphaFunction *)jarg1;
43082   {
43083     try {
43084       delete arg1;
43085     } catch (std::out_of_range& e) {
43086       {
43087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43088       };
43089     } catch (std::exception& e) {
43090       {
43091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43092       };
43093     } catch (Dali::DaliException e) {
43094       {
43095         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43096       };
43097     } catch (...) {
43098       {
43099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43100       };
43101     }
43102   }
43103
43104 }
43105
43106
43107 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_New() {
43108   void * jresult ;
43109   Dali::KeyFrames result;
43110
43111   {
43112     try {
43113       result = Dali::KeyFrames::New();
43114     } catch (std::out_of_range& e) {
43115       {
43116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43117       };
43118     } catch (std::exception& e) {
43119       {
43120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43121       };
43122     } catch (Dali::DaliException e) {
43123       {
43124         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43125       };
43126     } catch (...) {
43127       {
43128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43129       };
43130     }
43131   }
43132
43133   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
43134   return jresult;
43135 }
43136
43137
43138 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_DownCast(void * jarg1) {
43139   void * jresult ;
43140   Dali::BaseHandle arg1 ;
43141   Dali::BaseHandle *argp1 ;
43142   Dali::KeyFrames result;
43143
43144   argp1 = (Dali::BaseHandle *)jarg1;
43145   if (!argp1) {
43146     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43147     return 0;
43148   }
43149   arg1 = *argp1;
43150   {
43151     try {
43152       result = Dali::KeyFrames::DownCast(arg1);
43153     } catch (std::out_of_range& e) {
43154       {
43155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43156       };
43157     } catch (std::exception& e) {
43158       {
43159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43160       };
43161     } catch (Dali::DaliException e) {
43162       {
43163         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43164       };
43165     } catch (...) {
43166       {
43167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43168       };
43169     }
43170   }
43171
43172   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
43173   return jresult;
43174 }
43175
43176
43177 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_0() {
43178   void * jresult ;
43179   Dali::KeyFrames *result = 0 ;
43180
43181   {
43182     try {
43183       result = (Dali::KeyFrames *)new Dali::KeyFrames();
43184     } catch (std::out_of_range& e) {
43185       {
43186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43187       };
43188     } catch (std::exception& e) {
43189       {
43190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43191       };
43192     } catch (Dali::DaliException e) {
43193       {
43194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43195       };
43196     } catch (...) {
43197       {
43198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43199       };
43200     }
43201   }
43202
43203   jresult = (void *)result;
43204   return jresult;
43205 }
43206
43207
43208 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyFrames(void * jarg1) {
43209   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43210
43211   arg1 = (Dali::KeyFrames *)jarg1;
43212   {
43213     try {
43214       delete arg1;
43215     } catch (std::out_of_range& e) {
43216       {
43217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43218       };
43219     } catch (std::exception& e) {
43220       {
43221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43222       };
43223     } catch (Dali::DaliException e) {
43224       {
43225         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43226       };
43227     } catch (...) {
43228       {
43229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43230       };
43231     }
43232   }
43233
43234 }
43235
43236
43237 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_1(void * jarg1) {
43238   void * jresult ;
43239   Dali::KeyFrames *arg1 = 0 ;
43240   Dali::KeyFrames *result = 0 ;
43241
43242   arg1 = (Dali::KeyFrames *)jarg1;
43243   if (!arg1) {
43244     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
43245     return 0;
43246   }
43247   {
43248     try {
43249       result = (Dali::KeyFrames *)new Dali::KeyFrames((Dali::KeyFrames const &)*arg1);
43250     } catch (std::out_of_range& e) {
43251       {
43252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43253       };
43254     } catch (std::exception& e) {
43255       {
43256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43257       };
43258     } catch (Dali::DaliException e) {
43259       {
43260         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43261       };
43262     } catch (...) {
43263       {
43264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43265       };
43266     }
43267   }
43268
43269   jresult = (void *)result;
43270   return jresult;
43271 }
43272
43273
43274 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_Assign(void * jarg1, void * jarg2) {
43275   void * jresult ;
43276   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43277   Dali::KeyFrames *arg2 = 0 ;
43278   Dali::KeyFrames *result = 0 ;
43279
43280   arg1 = (Dali::KeyFrames *)jarg1;
43281   arg2 = (Dali::KeyFrames *)jarg2;
43282   if (!arg2) {
43283     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
43284     return 0;
43285   }
43286   {
43287     try {
43288       result = (Dali::KeyFrames *) &(arg1)->operator =((Dali::KeyFrames const &)*arg2);
43289     } catch (std::out_of_range& e) {
43290       {
43291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43292       };
43293     } catch (std::exception& e) {
43294       {
43295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43296       };
43297     } catch (Dali::DaliException e) {
43298       {
43299         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43300       };
43301     } catch (...) {
43302       {
43303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43304       };
43305     }
43306   }
43307
43308   jresult = (void *)result;
43309   return jresult;
43310 }
43311
43312
43313 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_KeyFrames_GetType(void * jarg1) {
43314   int jresult ;
43315   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43316   Dali::Property::Type result;
43317
43318   arg1 = (Dali::KeyFrames *)jarg1;
43319   {
43320     try {
43321       result = (Dali::Property::Type)((Dali::KeyFrames const *)arg1)->GetType();
43322     } catch (std::out_of_range& e) {
43323       {
43324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43325       };
43326     } catch (std::exception& e) {
43327       {
43328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43329       };
43330     } catch (Dali::DaliException e) {
43331       {
43332         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43333       };
43334     } catch (...) {
43335       {
43336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43337       };
43338     }
43339   }
43340
43341   jresult = (int)result;
43342   return jresult;
43343 }
43344
43345
43346 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_0(void * jarg1, float jarg2, void * jarg3) {
43347   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43348   float arg2 ;
43349   Dali::Property::Value arg3 ;
43350   Dali::Property::Value *argp3 ;
43351
43352   arg1 = (Dali::KeyFrames *)jarg1;
43353   arg2 = (float)jarg2;
43354   argp3 = (Dali::Property::Value *)jarg3;
43355   if (!argp3) {
43356     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
43357     return ;
43358   }
43359   arg3 = *argp3;
43360   {
43361     try {
43362       (arg1)->Add(arg2,arg3);
43363     } catch (std::out_of_range& e) {
43364       {
43365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43366       };
43367     } catch (std::exception& e) {
43368       {
43369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43370       };
43371     } catch (Dali::DaliException e) {
43372       {
43373         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43374       };
43375     } catch (...) {
43376       {
43377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43378       };
43379     }
43380   }
43381
43382 }
43383
43384
43385 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_1(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
43386   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43387   float arg2 ;
43388   Dali::Property::Value arg3 ;
43389   Dali::AlphaFunction arg4 ;
43390   Dali::Property::Value *argp3 ;
43391   Dali::AlphaFunction *argp4 ;
43392
43393   arg1 = (Dali::KeyFrames *)jarg1;
43394   arg2 = (float)jarg2;
43395   argp3 = (Dali::Property::Value *)jarg3;
43396   if (!argp3) {
43397     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
43398     return ;
43399   }
43400   arg3 = *argp3;
43401   argp4 = (Dali::AlphaFunction *)jarg4;
43402   if (!argp4) {
43403     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
43404     return ;
43405   }
43406   arg4 = *argp4;
43407   {
43408     try {
43409       (arg1)->Add(arg2,arg3,arg4);
43410     } catch (std::out_of_range& e) {
43411       {
43412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43413       };
43414     } catch (std::exception& e) {
43415       {
43416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43417       };
43418     } catch (Dali::DaliException e) {
43419       {
43420         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43421       };
43422     } catch (...) {
43423       {
43424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43425       };
43426     }
43427   }
43428
43429 }
43430
43431
43432 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_POINTS_get() {
43433   int jresult ;
43434   int result;
43435
43436   result = (int)Dali::Path::Property::POINTS;
43437   jresult = (int)result;
43438   return jresult;
43439 }
43440
43441
43442 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_CONTROL_POINTS_get() {
43443   int jresult ;
43444   int result;
43445
43446   result = (int)Dali::Path::Property::CONTROL_POINTS;
43447   jresult = (int)result;
43448   return jresult;
43449 }
43450
43451
43452 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path_Property() {
43453   void * jresult ;
43454   Dali::Path::Property *result = 0 ;
43455
43456   {
43457     try {
43458       result = (Dali::Path::Property *)new Dali::Path::Property();
43459     } catch (std::out_of_range& e) {
43460       {
43461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43462       };
43463     } catch (std::exception& e) {
43464       {
43465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43466       };
43467     } catch (Dali::DaliException e) {
43468       {
43469         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43470       };
43471     } catch (...) {
43472       {
43473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43474       };
43475     }
43476   }
43477
43478   jresult = (void *)result;
43479   return jresult;
43480 }
43481
43482
43483 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path_Property(void * jarg1) {
43484   Dali::Path::Property *arg1 = (Dali::Path::Property *) 0 ;
43485
43486   arg1 = (Dali::Path::Property *)jarg1;
43487   {
43488     try {
43489       delete arg1;
43490     } catch (std::out_of_range& e) {
43491       {
43492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43493       };
43494     } catch (std::exception& e) {
43495       {
43496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43497       };
43498     } catch (Dali::DaliException e) {
43499       {
43500         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43501       };
43502     } catch (...) {
43503       {
43504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43505       };
43506     }
43507   }
43508
43509 }
43510
43511
43512 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_New() {
43513   void * jresult ;
43514   Dali::Path result;
43515
43516   {
43517     try {
43518       result = Dali::Path::New();
43519     } catch (std::out_of_range& e) {
43520       {
43521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43522       };
43523     } catch (std::exception& e) {
43524       {
43525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43526       };
43527     } catch (Dali::DaliException e) {
43528       {
43529         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43530       };
43531     } catch (...) {
43532       {
43533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43534       };
43535     }
43536   }
43537
43538   jresult = new Dali::Path((const Dali::Path &)result);
43539   return jresult;
43540 }
43541
43542
43543 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_DownCast(void * jarg1) {
43544   void * jresult ;
43545   Dali::BaseHandle arg1 ;
43546   Dali::BaseHandle *argp1 ;
43547   Dali::Path result;
43548
43549   argp1 = (Dali::BaseHandle *)jarg1;
43550   if (!argp1) {
43551     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43552     return 0;
43553   }
43554   arg1 = *argp1;
43555   {
43556     try {
43557       result = Dali::Path::DownCast(arg1);
43558     } catch (std::out_of_range& e) {
43559       {
43560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43561       };
43562     } catch (std::exception& e) {
43563       {
43564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43565       };
43566     } catch (Dali::DaliException e) {
43567       {
43568         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43569       };
43570     } catch (...) {
43571       {
43572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43573       };
43574     }
43575   }
43576
43577   jresult = new Dali::Path((const Dali::Path &)result);
43578   return jresult;
43579 }
43580
43581
43582 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_0() {
43583   void * jresult ;
43584   Dali::Path *result = 0 ;
43585
43586   {
43587     try {
43588       result = (Dali::Path *)new Dali::Path();
43589     } catch (std::out_of_range& e) {
43590       {
43591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43592       };
43593     } catch (std::exception& e) {
43594       {
43595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43596       };
43597     } catch (Dali::DaliException e) {
43598       {
43599         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43600       };
43601     } catch (...) {
43602       {
43603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43604       };
43605     }
43606   }
43607
43608   jresult = (void *)result;
43609   return jresult;
43610 }
43611
43612
43613 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path(void * jarg1) {
43614   Dali::Path *arg1 = (Dali::Path *) 0 ;
43615
43616   arg1 = (Dali::Path *)jarg1;
43617   {
43618     try {
43619       delete arg1;
43620     } catch (std::out_of_range& e) {
43621       {
43622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43623       };
43624     } catch (std::exception& e) {
43625       {
43626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43627       };
43628     } catch (Dali::DaliException e) {
43629       {
43630         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43631       };
43632     } catch (...) {
43633       {
43634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43635       };
43636     }
43637   }
43638
43639 }
43640
43641
43642 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_1(void * jarg1) {
43643   void * jresult ;
43644   Dali::Path *arg1 = 0 ;
43645   Dali::Path *result = 0 ;
43646
43647   arg1 = (Dali::Path *)jarg1;
43648   if (!arg1) {
43649     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
43650     return 0;
43651   }
43652   {
43653     try {
43654       result = (Dali::Path *)new Dali::Path((Dali::Path const &)*arg1);
43655     } catch (std::out_of_range& e) {
43656       {
43657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43658       };
43659     } catch (std::exception& e) {
43660       {
43661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43662       };
43663     } catch (Dali::DaliException e) {
43664       {
43665         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43666       };
43667     } catch (...) {
43668       {
43669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43670       };
43671     }
43672   }
43673
43674   jresult = (void *)result;
43675   return jresult;
43676 }
43677
43678
43679 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_Assign(void * jarg1, void * jarg2) {
43680   void * jresult ;
43681   Dali::Path *arg1 = (Dali::Path *) 0 ;
43682   Dali::Path *arg2 = 0 ;
43683   Dali::Path *result = 0 ;
43684
43685   arg1 = (Dali::Path *)jarg1;
43686   arg2 = (Dali::Path *)jarg2;
43687   if (!arg2) {
43688     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
43689     return 0;
43690   }
43691   {
43692     try {
43693       result = (Dali::Path *) &(arg1)->operator =((Dali::Path const &)*arg2);
43694     } catch (std::out_of_range& e) {
43695       {
43696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43697       };
43698     } catch (std::exception& e) {
43699       {
43700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43701       };
43702     } catch (Dali::DaliException e) {
43703       {
43704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43705       };
43706     } catch (...) {
43707       {
43708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43709       };
43710     }
43711   }
43712
43713   jresult = (void *)result;
43714   return jresult;
43715 }
43716
43717
43718 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddPoint(void * jarg1, void * jarg2) {
43719   Dali::Path *arg1 = (Dali::Path *) 0 ;
43720   Dali::Vector3 *arg2 = 0 ;
43721
43722   arg1 = (Dali::Path *)jarg1;
43723   arg2 = (Dali::Vector3 *)jarg2;
43724   if (!arg2) {
43725     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
43726     return ;
43727   }
43728   {
43729     try {
43730       (arg1)->AddPoint((Dali::Vector3 const &)*arg2);
43731     } catch (std::out_of_range& e) {
43732       {
43733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43734       };
43735     } catch (std::exception& e) {
43736       {
43737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43738       };
43739     } catch (Dali::DaliException e) {
43740       {
43741         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43742       };
43743     } catch (...) {
43744       {
43745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43746       };
43747     }
43748   }
43749
43750 }
43751
43752
43753 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddControlPoint(void * jarg1, void * jarg2) {
43754   Dali::Path *arg1 = (Dali::Path *) 0 ;
43755   Dali::Vector3 *arg2 = 0 ;
43756
43757   arg1 = (Dali::Path *)jarg1;
43758   arg2 = (Dali::Vector3 *)jarg2;
43759   if (!arg2) {
43760     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
43761     return ;
43762   }
43763   {
43764     try {
43765       (arg1)->AddControlPoint((Dali::Vector3 const &)*arg2);
43766     } catch (std::out_of_range& e) {
43767       {
43768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43769       };
43770     } catch (std::exception& e) {
43771       {
43772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43773       };
43774     } catch (Dali::DaliException e) {
43775       {
43776         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43777       };
43778     } catch (...) {
43779       {
43780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43781       };
43782     }
43783   }
43784
43785 }
43786
43787
43788 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_GenerateControlPoints(void * jarg1, float jarg2) {
43789   Dali::Path *arg1 = (Dali::Path *) 0 ;
43790   float arg2 ;
43791
43792   arg1 = (Dali::Path *)jarg1;
43793   arg2 = (float)jarg2;
43794   {
43795     try {
43796       (arg1)->GenerateControlPoints(arg2);
43797     } catch (std::out_of_range& e) {
43798       {
43799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43800       };
43801     } catch (std::exception& e) {
43802       {
43803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43804       };
43805     } catch (Dali::DaliException e) {
43806       {
43807         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43808       };
43809     } catch (...) {
43810       {
43811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43812       };
43813     }
43814   }
43815
43816 }
43817
43818
43819 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_Sample(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
43820   Dali::Path *arg1 = (Dali::Path *) 0 ;
43821   float arg2 ;
43822   Dali::Vector3 *arg3 = 0 ;
43823   Dali::Vector3 *arg4 = 0 ;
43824
43825   arg1 = (Dali::Path *)jarg1;
43826   arg2 = (float)jarg2;
43827   arg3 = (Dali::Vector3 *)jarg3;
43828   if (!arg3) {
43829     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
43830     return ;
43831   }
43832   arg4 = (Dali::Vector3 *)jarg4;
43833   if (!arg4) {
43834     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
43835     return ;
43836   }
43837   {
43838     try {
43839       ((Dali::Path const *)arg1)->Sample(arg2,*arg3,*arg4);
43840     } catch (std::out_of_range& e) {
43841       {
43842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43843       };
43844     } catch (std::exception& e) {
43845       {
43846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43847       };
43848     } catch (Dali::DaliException e) {
43849       {
43850         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43851       };
43852     } catch (...) {
43853       {
43854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43855       };
43856     }
43857   }
43858
43859 }
43860
43861
43862 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetPoint(void * jarg1, unsigned long jarg2) {
43863   void * jresult ;
43864   Dali::Path *arg1 = (Dali::Path *) 0 ;
43865   size_t arg2 ;
43866   Dali::Vector3 *result = 0 ;
43867
43868   arg1 = (Dali::Path *)jarg1;
43869   arg2 = (size_t)jarg2;
43870   {
43871     try {
43872       result = (Dali::Vector3 *) &(arg1)->GetPoint(arg2);
43873     } catch (std::out_of_range& e) {
43874       {
43875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43876       };
43877     } catch (std::exception& e) {
43878       {
43879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43880       };
43881     } catch (Dali::DaliException e) {
43882       {
43883         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43884       };
43885     } catch (...) {
43886       {
43887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43888       };
43889     }
43890   }
43891
43892   jresult = (void *)result;
43893   return jresult;
43894 }
43895
43896
43897 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetControlPoint(void * jarg1, unsigned long jarg2) {
43898   void * jresult ;
43899   Dali::Path *arg1 = (Dali::Path *) 0 ;
43900   size_t arg2 ;
43901   Dali::Vector3 *result = 0 ;
43902
43903   arg1 = (Dali::Path *)jarg1;
43904   arg2 = (size_t)jarg2;
43905   {
43906     try {
43907       result = (Dali::Vector3 *) &(arg1)->GetControlPoint(arg2);
43908     } catch (std::out_of_range& e) {
43909       {
43910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43911       };
43912     } catch (std::exception& e) {
43913       {
43914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43915       };
43916     } catch (Dali::DaliException e) {
43917       {
43918         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43919       };
43920     } catch (...) {
43921       {
43922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43923       };
43924     }
43925   }
43926
43927   jresult = (void *)result;
43928   return jresult;
43929 }
43930
43931
43932 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Path_GetPointCount(void * jarg1) {
43933   unsigned long jresult ;
43934   Dali::Path *arg1 = (Dali::Path *) 0 ;
43935   size_t result;
43936
43937   arg1 = (Dali::Path *)jarg1;
43938   {
43939     try {
43940       result = ((Dali::Path const *)arg1)->GetPointCount();
43941     } catch (std::out_of_range& e) {
43942       {
43943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43944       };
43945     } catch (std::exception& e) {
43946       {
43947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43948       };
43949     } catch (Dali::DaliException e) {
43950       {
43951         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43952       };
43953     } catch (...) {
43954       {
43955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43956       };
43957     }
43958   }
43959
43960   jresult = (unsigned long)result;
43961   return jresult;
43962 }
43963
43964
43965 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_0(float jarg1) {
43966   void * jresult ;
43967   float arg1 ;
43968   Dali::TimePeriod *result = 0 ;
43969
43970   arg1 = (float)jarg1;
43971   {
43972     try {
43973       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1);
43974     } catch (std::out_of_range& e) {
43975       {
43976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43977       };
43978     } catch (std::exception& e) {
43979       {
43980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43981       };
43982     } catch (Dali::DaliException e) {
43983       {
43984         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43985       };
43986     } catch (...) {
43987       {
43988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43989       };
43990     }
43991   }
43992
43993   jresult = (void *)result;
43994   return jresult;
43995 }
43996
43997
43998 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_1(float jarg1, float jarg2) {
43999   void * jresult ;
44000   float arg1 ;
44001   float arg2 ;
44002   Dali::TimePeriod *result = 0 ;
44003
44004   arg1 = (float)jarg1;
44005   arg2 = (float)jarg2;
44006   {
44007     try {
44008       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1,arg2);
44009     } catch (std::out_of_range& e) {
44010       {
44011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44012       };
44013     } catch (std::exception& e) {
44014       {
44015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44016       };
44017     } catch (Dali::DaliException e) {
44018       {
44019         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44020       };
44021     } catch (...) {
44022       {
44023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44024       };
44025     }
44026   }
44027
44028   jresult = (void *)result;
44029   return jresult;
44030 }
44031
44032
44033 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimePeriod(void * jarg1) {
44034   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44035
44036   arg1 = (Dali::TimePeriod *)jarg1;
44037   {
44038     try {
44039       delete arg1;
44040     } catch (std::out_of_range& e) {
44041       {
44042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44043       };
44044     } catch (std::exception& e) {
44045       {
44046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44047       };
44048     } catch (Dali::DaliException e) {
44049       {
44050         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44051       };
44052     } catch (...) {
44053       {
44054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44055       };
44056     }
44057   }
44058
44059 }
44060
44061
44062 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_set(void * jarg1, float jarg2) {
44063   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44064   float arg2 ;
44065
44066   arg1 = (Dali::TimePeriod *)jarg1;
44067   arg2 = (float)jarg2;
44068   if (arg1) (arg1)->delaySeconds = arg2;
44069 }
44070
44071
44072 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_get(void * jarg1) {
44073   float jresult ;
44074   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44075   float result;
44076
44077   arg1 = (Dali::TimePeriod *)jarg1;
44078   result = (float) ((arg1)->delaySeconds);
44079   jresult = result;
44080   return jresult;
44081 }
44082
44083
44084 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_set(void * jarg1, float jarg2) {
44085   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44086   float arg2 ;
44087
44088   arg1 = (Dali::TimePeriod *)jarg1;
44089   arg2 = (float)jarg2;
44090   if (arg1) (arg1)->durationSeconds = arg2;
44091 }
44092
44093
44094 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_get(void * jarg1) {
44095   float jresult ;
44096   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44097   float result;
44098
44099   arg1 = (Dali::TimePeriod *)jarg1;
44100   result = (float) ((arg1)->durationSeconds);
44101   jresult = result;
44102   return jresult;
44103 }
44104
44105 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_VALUE_get() {
44106   int jresult ;
44107   int result;
44108
44109   result = (int)Dali::LinearConstrainer::Property::VALUE;
44110   jresult = (int)result;
44111   return jresult;
44112 }
44113
44114
44115 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_PROGRESS_get() {
44116   int jresult ;
44117   int result;
44118
44119   result = (int)Dali::LinearConstrainer::Property::PROGRESS;
44120   jresult = (int)result;
44121   return jresult;
44122 }
44123
44124
44125 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer_Property() {
44126   void * jresult ;
44127   Dali::LinearConstrainer::Property *result = 0 ;
44128
44129   {
44130     try {
44131       result = (Dali::LinearConstrainer::Property *)new Dali::LinearConstrainer::Property();
44132     } catch (std::out_of_range& e) {
44133       {
44134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44135       };
44136     } catch (std::exception& e) {
44137       {
44138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44139       };
44140     } catch (Dali::DaliException e) {
44141       {
44142         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44143       };
44144     } catch (...) {
44145       {
44146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44147       };
44148     }
44149   }
44150
44151   jresult = (void *)result;
44152   return jresult;
44153 }
44154
44155
44156 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer_Property(void * jarg1) {
44157   Dali::LinearConstrainer::Property *arg1 = (Dali::LinearConstrainer::Property *) 0 ;
44158
44159   arg1 = (Dali::LinearConstrainer::Property *)jarg1;
44160   {
44161     try {
44162       delete arg1;
44163     } catch (std::out_of_range& e) {
44164       {
44165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44166       };
44167     } catch (std::exception& e) {
44168       {
44169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44170       };
44171     } catch (Dali::DaliException e) {
44172       {
44173         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44174       };
44175     } catch (...) {
44176       {
44177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44178       };
44179     }
44180   }
44181
44182 }
44183
44184
44185 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_New() {
44186   void * jresult ;
44187   Dali::LinearConstrainer result;
44188
44189   {
44190     try {
44191       result = Dali::LinearConstrainer::New();
44192     } catch (std::out_of_range& e) {
44193       {
44194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44195       };
44196     } catch (std::exception& e) {
44197       {
44198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44199       };
44200     } catch (Dali::DaliException e) {
44201       {
44202         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44203       };
44204     } catch (...) {
44205       {
44206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44207       };
44208     }
44209   }
44210
44211   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
44212   return jresult;
44213 }
44214
44215
44216 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_DownCast(void * jarg1) {
44217   void * jresult ;
44218   Dali::BaseHandle arg1 ;
44219   Dali::BaseHandle *argp1 ;
44220   Dali::LinearConstrainer result;
44221
44222   argp1 = (Dali::BaseHandle *)jarg1;
44223   if (!argp1) {
44224     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
44225     return 0;
44226   }
44227   arg1 = *argp1;
44228   {
44229     try {
44230       result = Dali::LinearConstrainer::DownCast(arg1);
44231     } catch (std::out_of_range& e) {
44232       {
44233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44234       };
44235     } catch (std::exception& e) {
44236       {
44237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44238       };
44239     } catch (Dali::DaliException e) {
44240       {
44241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44242       };
44243     } catch (...) {
44244       {
44245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44246       };
44247     }
44248   }
44249
44250   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
44251   return jresult;
44252 }
44253
44254
44255 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_0() {
44256   void * jresult ;
44257   Dali::LinearConstrainer *result = 0 ;
44258
44259   {
44260     try {
44261       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer();
44262     } catch (std::out_of_range& e) {
44263       {
44264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44265       };
44266     } catch (std::exception& e) {
44267       {
44268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44269       };
44270     } catch (Dali::DaliException e) {
44271       {
44272         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44273       };
44274     } catch (...) {
44275       {
44276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44277       };
44278     }
44279   }
44280
44281   jresult = (void *)result;
44282   return jresult;
44283 }
44284
44285
44286 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer(void * jarg1) {
44287   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44288
44289   arg1 = (Dali::LinearConstrainer *)jarg1;
44290   {
44291     try {
44292       delete arg1;
44293     } catch (std::out_of_range& e) {
44294       {
44295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44296       };
44297     } catch (std::exception& e) {
44298       {
44299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44300       };
44301     } catch (Dali::DaliException e) {
44302       {
44303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44304       };
44305     } catch (...) {
44306       {
44307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44308       };
44309     }
44310   }
44311
44312 }
44313
44314
44315 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_1(void * jarg1) {
44316   void * jresult ;
44317   Dali::LinearConstrainer *arg1 = 0 ;
44318   Dali::LinearConstrainer *result = 0 ;
44319
44320   arg1 = (Dali::LinearConstrainer *)jarg1;
44321   if (!arg1) {
44322     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
44323     return 0;
44324   }
44325   {
44326     try {
44327       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer((Dali::LinearConstrainer const &)*arg1);
44328     } catch (std::out_of_range& e) {
44329       {
44330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44331       };
44332     } catch (std::exception& e) {
44333       {
44334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44335       };
44336     } catch (Dali::DaliException e) {
44337       {
44338         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44339       };
44340     } catch (...) {
44341       {
44342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44343       };
44344     }
44345   }
44346
44347   jresult = (void *)result;
44348   return jresult;
44349 }
44350
44351
44352 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_Assign(void * jarg1, void * jarg2) {
44353   void * jresult ;
44354   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44355   Dali::LinearConstrainer *arg2 = 0 ;
44356   Dali::LinearConstrainer *result = 0 ;
44357
44358   arg1 = (Dali::LinearConstrainer *)jarg1;
44359   arg2 = (Dali::LinearConstrainer *)jarg2;
44360   if (!arg2) {
44361     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
44362     return 0;
44363   }
44364   {
44365     try {
44366       result = (Dali::LinearConstrainer *) &(arg1)->operator =((Dali::LinearConstrainer const &)*arg2);
44367     } catch (std::out_of_range& e) {
44368       {
44369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44370       };
44371     } catch (std::exception& e) {
44372       {
44373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44374       };
44375     } catch (Dali::DaliException e) {
44376       {
44377         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44378       };
44379     } catch (...) {
44380       {
44381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44382       };
44383     }
44384   }
44385
44386   jresult = (void *)result;
44387   return jresult;
44388 }
44389
44390
44391 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
44392   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44393   SwigValueWrapper< Dali::Property > arg2 ;
44394   SwigValueWrapper< Dali::Property > arg3 ;
44395   Dali::Vector2 *arg4 = 0 ;
44396   Dali::Vector2 *arg5 = 0 ;
44397   Dali::Property *argp2 ;
44398   Dali::Property *argp3 ;
44399
44400   arg1 = (Dali::LinearConstrainer *)jarg1;
44401   argp2 = (Dali::Property *)jarg2;
44402   if (!argp2) {
44403     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44404     return ;
44405   }
44406   arg2 = *argp2;
44407   argp3 = (Dali::Property *)jarg3;
44408   if (!argp3) {
44409     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44410     return ;
44411   }
44412   arg3 = *argp3;
44413   arg4 = (Dali::Vector2 *)jarg4;
44414   if (!arg4) {
44415     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44416     return ;
44417   }
44418   arg5 = (Dali::Vector2 *)jarg5;
44419   if (!arg5) {
44420     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44421     return ;
44422   }
44423   {
44424     try {
44425       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
44426     } catch (std::out_of_range& e) {
44427       {
44428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44429       };
44430     } catch (std::exception& e) {
44431       {
44432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44433       };
44434     } catch (Dali::DaliException e) {
44435       {
44436         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44437       };
44438     } catch (...) {
44439       {
44440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44441       };
44442     }
44443   }
44444
44445 }
44446
44447
44448 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
44449   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44450   SwigValueWrapper< Dali::Property > arg2 ;
44451   SwigValueWrapper< Dali::Property > arg3 ;
44452   Dali::Vector2 *arg4 = 0 ;
44453   Dali::Property *argp2 ;
44454   Dali::Property *argp3 ;
44455
44456   arg1 = (Dali::LinearConstrainer *)jarg1;
44457   argp2 = (Dali::Property *)jarg2;
44458   if (!argp2) {
44459     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44460     return ;
44461   }
44462   arg2 = *argp2;
44463   argp3 = (Dali::Property *)jarg3;
44464   if (!argp3) {
44465     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44466     return ;
44467   }
44468   arg3 = *argp3;
44469   arg4 = (Dali::Vector2 *)jarg4;
44470   if (!arg4) {
44471     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44472     return ;
44473   }
44474   {
44475     try {
44476       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
44477     } catch (std::out_of_range& e) {
44478       {
44479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44480       };
44481     } catch (std::exception& e) {
44482       {
44483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44484       };
44485     } catch (Dali::DaliException e) {
44486       {
44487         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44488       };
44489     } catch (...) {
44490       {
44491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44492       };
44493     }
44494   }
44495
44496 }
44497
44498
44499 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Remove(void * jarg1, void * jarg2) {
44500   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44501   Dali::Handle *arg2 = 0 ;
44502
44503   arg1 = (Dali::LinearConstrainer *)jarg1;
44504   arg2 = (Dali::Handle *)jarg2;
44505   if (!arg2) {
44506     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
44507     return ;
44508   }
44509   {
44510     try {
44511       (arg1)->Remove(*arg2);
44512     } catch (std::out_of_range& e) {
44513       {
44514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44515       };
44516     } catch (std::exception& e) {
44517       {
44518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44519       };
44520     } catch (Dali::DaliException e) {
44521       {
44522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44523       };
44524     } catch (...) {
44525       {
44526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44527       };
44528     }
44529   }
44530
44531 }
44532
44533
44534 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_FORWARD_get() {
44535   int jresult ;
44536   int result;
44537
44538   result = (int)Dali::PathConstrainer::Property::FORWARD;
44539   jresult = (int)result;
44540   return jresult;
44541 }
44542
44543
44544 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_POINTS_get() {
44545   int jresult ;
44546   int result;
44547
44548   result = (int)Dali::PathConstrainer::Property::POINTS;
44549   jresult = (int)result;
44550   return jresult;
44551 }
44552
44553
44554 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_CONTROL_POINTS_get() {
44555   int jresult ;
44556   int result;
44557
44558   result = (int)Dali::PathConstrainer::Property::CONTROL_POINTS;
44559   jresult = (int)result;
44560   return jresult;
44561 }
44562
44563
44564 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer_Property() {
44565   void * jresult ;
44566   Dali::PathConstrainer::Property *result = 0 ;
44567
44568   {
44569     try {
44570       result = (Dali::PathConstrainer::Property *)new Dali::PathConstrainer::Property();
44571     } catch (std::out_of_range& e) {
44572       {
44573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44574       };
44575     } catch (std::exception& e) {
44576       {
44577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44578       };
44579     } catch (Dali::DaliException e) {
44580       {
44581         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44582       };
44583     } catch (...) {
44584       {
44585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44586       };
44587     }
44588   }
44589
44590   jresult = (void *)result;
44591   return jresult;
44592 }
44593
44594
44595 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer_Property(void * jarg1) {
44596   Dali::PathConstrainer::Property *arg1 = (Dali::PathConstrainer::Property *) 0 ;
44597
44598   arg1 = (Dali::PathConstrainer::Property *)jarg1;
44599   {
44600     try {
44601       delete arg1;
44602     } catch (std::out_of_range& e) {
44603       {
44604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44605       };
44606     } catch (std::exception& e) {
44607       {
44608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44609       };
44610     } catch (Dali::DaliException e) {
44611       {
44612         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44613       };
44614     } catch (...) {
44615       {
44616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44617       };
44618     }
44619   }
44620
44621 }
44622
44623
44624 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_New() {
44625   void * jresult ;
44626   Dali::PathConstrainer result;
44627
44628   {
44629     try {
44630       result = Dali::PathConstrainer::New();
44631     } catch (std::out_of_range& e) {
44632       {
44633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44634       };
44635     } catch (std::exception& e) {
44636       {
44637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44638       };
44639     } catch (Dali::DaliException e) {
44640       {
44641         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44642       };
44643     } catch (...) {
44644       {
44645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44646       };
44647     }
44648   }
44649
44650   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
44651   return jresult;
44652 }
44653
44654
44655 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_DownCast(void * jarg1) {
44656   void * jresult ;
44657   Dali::BaseHandle arg1 ;
44658   Dali::BaseHandle *argp1 ;
44659   Dali::PathConstrainer result;
44660
44661   argp1 = (Dali::BaseHandle *)jarg1;
44662   if (!argp1) {
44663     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
44664     return 0;
44665   }
44666   arg1 = *argp1;
44667   {
44668     try {
44669       result = Dali::PathConstrainer::DownCast(arg1);
44670     } catch (std::out_of_range& e) {
44671       {
44672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44673       };
44674     } catch (std::exception& e) {
44675       {
44676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44677       };
44678     } catch (Dali::DaliException e) {
44679       {
44680         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44681       };
44682     } catch (...) {
44683       {
44684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44685       };
44686     }
44687   }
44688
44689   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
44690   return jresult;
44691 }
44692
44693
44694 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_0() {
44695   void * jresult ;
44696   Dali::PathConstrainer *result = 0 ;
44697
44698   {
44699     try {
44700       result = (Dali::PathConstrainer *)new Dali::PathConstrainer();
44701     } catch (std::out_of_range& e) {
44702       {
44703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44704       };
44705     } catch (std::exception& e) {
44706       {
44707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44708       };
44709     } catch (Dali::DaliException e) {
44710       {
44711         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44712       };
44713     } catch (...) {
44714       {
44715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44716       };
44717     }
44718   }
44719
44720   jresult = (void *)result;
44721   return jresult;
44722 }
44723
44724
44725 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer(void * jarg1) {
44726   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44727
44728   arg1 = (Dali::PathConstrainer *)jarg1;
44729   {
44730     try {
44731       delete arg1;
44732     } catch (std::out_of_range& e) {
44733       {
44734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44735       };
44736     } catch (std::exception& e) {
44737       {
44738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44739       };
44740     } catch (Dali::DaliException e) {
44741       {
44742         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44743       };
44744     } catch (...) {
44745       {
44746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44747       };
44748     }
44749   }
44750
44751 }
44752
44753
44754 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_1(void * jarg1) {
44755   void * jresult ;
44756   Dali::PathConstrainer *arg1 = 0 ;
44757   Dali::PathConstrainer *result = 0 ;
44758
44759   arg1 = (Dali::PathConstrainer *)jarg1;
44760   if (!arg1) {
44761     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
44762     return 0;
44763   }
44764   {
44765     try {
44766       result = (Dali::PathConstrainer *)new Dali::PathConstrainer((Dali::PathConstrainer const &)*arg1);
44767     } catch (std::out_of_range& e) {
44768       {
44769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44770       };
44771     } catch (std::exception& e) {
44772       {
44773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44774       };
44775     } catch (Dali::DaliException e) {
44776       {
44777         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44778       };
44779     } catch (...) {
44780       {
44781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44782       };
44783     }
44784   }
44785
44786   jresult = (void *)result;
44787   return jresult;
44788 }
44789
44790
44791 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_Assign(void * jarg1, void * jarg2) {
44792   void * jresult ;
44793   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44794   Dali::PathConstrainer *arg2 = 0 ;
44795   Dali::PathConstrainer *result = 0 ;
44796
44797   arg1 = (Dali::PathConstrainer *)jarg1;
44798   arg2 = (Dali::PathConstrainer *)jarg2;
44799   if (!arg2) {
44800     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
44801     return 0;
44802   }
44803   {
44804     try {
44805       result = (Dali::PathConstrainer *) &(arg1)->operator =((Dali::PathConstrainer const &)*arg2);
44806     } catch (std::out_of_range& e) {
44807       {
44808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44809       };
44810     } catch (std::exception& e) {
44811       {
44812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44813       };
44814     } catch (Dali::DaliException e) {
44815       {
44816         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44817       };
44818     } catch (...) {
44819       {
44820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44821       };
44822     }
44823   }
44824
44825   jresult = (void *)result;
44826   return jresult;
44827 }
44828
44829
44830 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
44831   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44832   SwigValueWrapper< Dali::Property > arg2 ;
44833   SwigValueWrapper< Dali::Property > arg3 ;
44834   Dali::Vector2 *arg4 = 0 ;
44835   Dali::Vector2 *arg5 = 0 ;
44836   Dali::Property *argp2 ;
44837   Dali::Property *argp3 ;
44838
44839   arg1 = (Dali::PathConstrainer *)jarg1;
44840   argp2 = (Dali::Property *)jarg2;
44841   if (!argp2) {
44842     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44843     return ;
44844   }
44845   arg2 = *argp2;
44846   argp3 = (Dali::Property *)jarg3;
44847   if (!argp3) {
44848     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44849     return ;
44850   }
44851   arg3 = *argp3;
44852   arg4 = (Dali::Vector2 *)jarg4;
44853   if (!arg4) {
44854     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44855     return ;
44856   }
44857   arg5 = (Dali::Vector2 *)jarg5;
44858   if (!arg5) {
44859     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44860     return ;
44861   }
44862   {
44863     try {
44864       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
44865     } catch (std::out_of_range& e) {
44866       {
44867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44868       };
44869     } catch (std::exception& e) {
44870       {
44871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44872       };
44873     } catch (Dali::DaliException e) {
44874       {
44875         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44876       };
44877     } catch (...) {
44878       {
44879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44880       };
44881     }
44882   }
44883
44884 }
44885
44886
44887 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
44888   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44889   SwigValueWrapper< Dali::Property > arg2 ;
44890   SwigValueWrapper< Dali::Property > arg3 ;
44891   Dali::Vector2 *arg4 = 0 ;
44892   Dali::Property *argp2 ;
44893   Dali::Property *argp3 ;
44894
44895   arg1 = (Dali::PathConstrainer *)jarg1;
44896   argp2 = (Dali::Property *)jarg2;
44897   if (!argp2) {
44898     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44899     return ;
44900   }
44901   arg2 = *argp2;
44902   argp3 = (Dali::Property *)jarg3;
44903   if (!argp3) {
44904     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44905     return ;
44906   }
44907   arg3 = *argp3;
44908   arg4 = (Dali::Vector2 *)jarg4;
44909   if (!arg4) {
44910     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44911     return ;
44912   }
44913   {
44914     try {
44915       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
44916     } catch (std::out_of_range& e) {
44917       {
44918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44919       };
44920     } catch (std::exception& e) {
44921       {
44922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44923       };
44924     } catch (Dali::DaliException e) {
44925       {
44926         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44927       };
44928     } catch (...) {
44929       {
44930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44931       };
44932     }
44933   }
44934
44935 }
44936
44937
44938 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Remove(void * jarg1, void * jarg2) {
44939   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44940   Dali::Handle *arg2 = 0 ;
44941
44942   arg1 = (Dali::PathConstrainer *)jarg1;
44943   arg2 = (Dali::Handle *)jarg2;
44944   if (!arg2) {
44945     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
44946     return ;
44947   }
44948   {
44949     try {
44950       (arg1)->Remove(*arg2);
44951     } catch (std::out_of_range& e) {
44952       {
44953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44954       };
44955     } catch (std::exception& e) {
44956       {
44957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44958       };
44959     } catch (Dali::DaliException e) {
44960       {
44961         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44962       };
44963     } catch (...) {
44964       {
44965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44966       };
44967     }
44968   }
44969
44970 }
44971
44972
44973 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FittingModeDefault_get() {
44974   int jresult ;
44975   Dali::FittingMode::Type result;
44976
44977   result = (Dali::FittingMode::Type)(Dali::FittingMode::Type)Dali::FittingMode::DEFAULT;
44978   jresult = (int)result;
44979   return jresult;
44980 }
44981
44982
44983 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_DEFAULT_get() {
44984   int jresult ;
44985   Dali::SamplingMode::Type result;
44986
44987   result = (Dali::SamplingMode::Type)(Dali::SamplingMode::Type)Dali::SamplingMode::DEFAULT;
44988   jresult = (int)result;
44989   return jresult;
44990 }
44991
44992
44993 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BufferImage__SWIG_0() {
44994   void * jresult ;
44995   Dali::BufferImage *result = 0 ;
44996
44997   {
44998     try {
44999       result = (Dali::BufferImage *)new Dali::BufferImage();
45000     } catch (std::out_of_range& e) {
45001       {
45002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45003       };
45004     } catch (std::exception& e) {
45005       {
45006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45007       };
45008     } catch (Dali::DaliException e) {
45009       {
45010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45011       };
45012     } catch (...) {
45013       {
45014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45015       };
45016     }
45017   }
45018
45019   jresult = (void *)result;
45020   return jresult;
45021 }
45022
45023
45024 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_0(unsigned int jarg1, unsigned int jarg2, int jarg3) {
45025   void * jresult ;
45026   unsigned int arg1 ;
45027   unsigned int arg2 ;
45028   Dali::Pixel::Format arg3 ;
45029   Dali::BufferImage result;
45030
45031   arg1 = (unsigned int)jarg1;
45032   arg2 = (unsigned int)jarg2;
45033   arg3 = (Dali::Pixel::Format)jarg3;
45034   {
45035     try {
45036       result = Dali::BufferImage::New(arg1,arg2,arg3);
45037     } catch (std::out_of_range& e) {
45038       {
45039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45040       };
45041     } catch (std::exception& e) {
45042       {
45043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45044       };
45045     } catch (Dali::DaliException e) {
45046       {
45047         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45048       };
45049     } catch (...) {
45050       {
45051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45052       };
45053     }
45054   }
45055
45056   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45057   return jresult;
45058 }
45059
45060
45061 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
45062   void * jresult ;
45063   unsigned int arg1 ;
45064   unsigned int arg2 ;
45065   Dali::BufferImage result;
45066
45067   arg1 = (unsigned int)jarg1;
45068   arg2 = (unsigned int)jarg2;
45069   {
45070     try {
45071       result = Dali::BufferImage::New(arg1,arg2);
45072     } catch (std::out_of_range& e) {
45073       {
45074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45075       };
45076     } catch (std::exception& e) {
45077       {
45078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45079       };
45080     } catch (Dali::DaliException e) {
45081       {
45082         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45083       };
45084     } catch (...) {
45085       {
45086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45087       };
45088     }
45089   }
45090
45091   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45092   return jresult;
45093 }
45094
45095
45096 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_2(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4, unsigned int jarg5) {
45097   void * jresult ;
45098   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
45099   unsigned int arg2 ;
45100   unsigned int arg3 ;
45101   Dali::Pixel::Format arg4 ;
45102   unsigned int arg5 ;
45103   Dali::BufferImage result;
45104
45105   arg1 = jarg1;
45106   arg2 = (unsigned int)jarg2;
45107   arg3 = (unsigned int)jarg3;
45108   arg4 = (Dali::Pixel::Format)jarg4;
45109   arg5 = (unsigned int)jarg5;
45110   {
45111     try {
45112       result = Dali::BufferImage::New(arg1,arg2,arg3,arg4,arg5);
45113     } catch (std::out_of_range& e) {
45114       {
45115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45116       };
45117     } catch (std::exception& e) {
45118       {
45119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45120       };
45121     } catch (Dali::DaliException e) {
45122       {
45123         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45124       };
45125     } catch (...) {
45126       {
45127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45128       };
45129     }
45130   }
45131
45132   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45133
45134
45135   return jresult;
45136 }
45137
45138
45139 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_3(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4) {
45140   void * jresult ;
45141   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
45142   unsigned int arg2 ;
45143   unsigned int arg3 ;
45144   Dali::Pixel::Format arg4 ;
45145   Dali::BufferImage result;
45146
45147   arg1 = jarg1;
45148   arg2 = (unsigned int)jarg2;
45149   arg3 = (unsigned int)jarg3;
45150   arg4 = (Dali::Pixel::Format)jarg4;
45151   {
45152     try {
45153       result = Dali::BufferImage::New(arg1,arg2,arg3,arg4);
45154     } catch (std::out_of_range& e) {
45155       {
45156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45157       };
45158     } catch (std::exception& e) {
45159       {
45160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45161       };
45162     } catch (Dali::DaliException e) {
45163       {
45164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45165       };
45166     } catch (...) {
45167       {
45168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45169       };
45170     }
45171   }
45172
45173   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45174
45175
45176   return jresult;
45177 }
45178
45179
45180 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_4(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3) {
45181   void * jresult ;
45182   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
45183   unsigned int arg2 ;
45184   unsigned int arg3 ;
45185   Dali::BufferImage result;
45186
45187   arg1 = jarg1;
45188   arg2 = (unsigned int)jarg2;
45189   arg3 = (unsigned int)jarg3;
45190   {
45191     try {
45192       result = Dali::BufferImage::New(arg1,arg2,arg3);
45193     } catch (std::out_of_range& e) {
45194       {
45195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45196       };
45197     } catch (std::exception& e) {
45198       {
45199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45200       };
45201     } catch (Dali::DaliException e) {
45202       {
45203         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45204       };
45205     } catch (...) {
45206       {
45207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45208       };
45209     }
45210   }
45211
45212   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45213
45214
45215   return jresult;
45216 }
45217
45218
45219 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_DownCast(void * jarg1) {
45220   void * jresult ;
45221   Dali::BaseHandle arg1 ;
45222   Dali::BaseHandle *argp1 ;
45223   Dali::BufferImage result;
45224
45225   argp1 = (Dali::BaseHandle *)jarg1;
45226   if (!argp1) {
45227     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
45228     return 0;
45229   }
45230   arg1 = *argp1;
45231   {
45232     try {
45233       result = Dali::BufferImage::DownCast(arg1);
45234     } catch (std::out_of_range& e) {
45235       {
45236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45237       };
45238     } catch (std::exception& e) {
45239       {
45240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45241       };
45242     } catch (Dali::DaliException e) {
45243       {
45244         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45245       };
45246     } catch (...) {
45247       {
45248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45249       };
45250     }
45251   }
45252
45253   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45254   return jresult;
45255 }
45256
45257
45258 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BufferImage(void * jarg1) {
45259   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45260
45261   arg1 = (Dali::BufferImage *)jarg1;
45262   {
45263     try {
45264       delete arg1;
45265     } catch (std::out_of_range& e) {
45266       {
45267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45268       };
45269     } catch (std::exception& e) {
45270       {
45271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45272       };
45273     } catch (Dali::DaliException e) {
45274       {
45275         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45276       };
45277     } catch (...) {
45278       {
45279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45280       };
45281     }
45282   }
45283
45284 }
45285
45286
45287 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BufferImage__SWIG_1(void * jarg1) {
45288   void * jresult ;
45289   Dali::BufferImage *arg1 = 0 ;
45290   Dali::BufferImage *result = 0 ;
45291
45292   arg1 = (Dali::BufferImage *)jarg1;
45293   if (!arg1) {
45294     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BufferImage const & type is null", 0);
45295     return 0;
45296   }
45297   {
45298     try {
45299       result = (Dali::BufferImage *)new Dali::BufferImage((Dali::BufferImage const &)*arg1);
45300     } catch (std::out_of_range& e) {
45301       {
45302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45303       };
45304     } catch (std::exception& e) {
45305       {
45306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45307       };
45308     } catch (Dali::DaliException e) {
45309       {
45310         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45311       };
45312     } catch (...) {
45313       {
45314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45315       };
45316     }
45317   }
45318
45319   jresult = (void *)result;
45320   return jresult;
45321 }
45322
45323
45324 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_Assign(void * jarg1, void * jarg2) {
45325   void * jresult ;
45326   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45327   Dali::BufferImage *arg2 = 0 ;
45328   Dali::BufferImage *result = 0 ;
45329
45330   arg1 = (Dali::BufferImage *)jarg1;
45331   arg2 = (Dali::BufferImage *)jarg2;
45332   if (!arg2) {
45333     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BufferImage const & type is null", 0);
45334     return 0;
45335   }
45336   {
45337     try {
45338       result = (Dali::BufferImage *) &(arg1)->operator =((Dali::BufferImage const &)*arg2);
45339     } catch (std::out_of_range& e) {
45340       {
45341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45342       };
45343     } catch (std::exception& e) {
45344       {
45345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45346       };
45347     } catch (Dali::DaliException e) {
45348       {
45349         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45350       };
45351     } catch (...) {
45352       {
45353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45354       };
45355     }
45356   }
45357
45358   jresult = (void *)result;
45359   return jresult;
45360 }
45361
45362
45363 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_WHITE() {
45364   void * jresult ;
45365   Dali::BufferImage result;
45366
45367   {
45368     try {
45369       result = Dali::BufferImage::WHITE();
45370     } catch (std::out_of_range& e) {
45371       {
45372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45373       };
45374     } catch (std::exception& e) {
45375       {
45376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45377       };
45378     } catch (Dali::DaliException e) {
45379       {
45380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45381       };
45382     } catch (...) {
45383       {
45384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45385       };
45386     }
45387   }
45388
45389   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45390   return jresult;
45391 }
45392
45393
45394 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_GetBuffer(void * jarg1) {
45395   void * jresult ;
45396   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45397   Dali::PixelBuffer *result = 0 ;
45398
45399   arg1 = (Dali::BufferImage *)jarg1;
45400   {
45401     try {
45402       result = (Dali::PixelBuffer *)(arg1)->GetBuffer();
45403     } catch (std::out_of_range& e) {
45404       {
45405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45406       };
45407     } catch (std::exception& e) {
45408       {
45409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45410       };
45411     } catch (Dali::DaliException e) {
45412       {
45413         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45414       };
45415     } catch (...) {
45416       {
45417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45418       };
45419     }
45420   }
45421
45422   jresult = (void *)result;
45423   return jresult;
45424 }
45425
45426
45427 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_GetBufferSize(void * jarg1) {
45428   unsigned int jresult ;
45429   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45430   unsigned int result;
45431
45432   arg1 = (Dali::BufferImage *)jarg1;
45433   {
45434     try {
45435       result = (unsigned int)((Dali::BufferImage const *)arg1)->GetBufferSize();
45436     } catch (std::out_of_range& e) {
45437       {
45438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45439       };
45440     } catch (std::exception& e) {
45441       {
45442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45443       };
45444     } catch (Dali::DaliException e) {
45445       {
45446         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45447       };
45448     } catch (...) {
45449       {
45450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45451       };
45452     }
45453   }
45454
45455   jresult = result;
45456   return jresult;
45457 }
45458
45459
45460 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_GetBufferStride(void * jarg1) {
45461   unsigned int jresult ;
45462   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45463   unsigned int result;
45464
45465   arg1 = (Dali::BufferImage *)jarg1;
45466   {
45467     try {
45468       result = (unsigned int)((Dali::BufferImage const *)arg1)->GetBufferStride();
45469     } catch (std::out_of_range& e) {
45470       {
45471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45472       };
45473     } catch (std::exception& e) {
45474       {
45475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45476       };
45477     } catch (Dali::DaliException e) {
45478       {
45479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45480       };
45481     } catch (...) {
45482       {
45483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45484       };
45485     }
45486   }
45487
45488   jresult = result;
45489   return jresult;
45490 }
45491
45492
45493 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BufferImage_GetPixelFormat(void * jarg1) {
45494   int jresult ;
45495   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45496   Dali::Pixel::Format result;
45497
45498   arg1 = (Dali::BufferImage *)jarg1;
45499   {
45500     try {
45501       result = (Dali::Pixel::Format)((Dali::BufferImage const *)arg1)->GetPixelFormat();
45502     } catch (std::out_of_range& e) {
45503       {
45504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45505       };
45506     } catch (std::exception& e) {
45507       {
45508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45509       };
45510     } catch (Dali::DaliException e) {
45511       {
45512         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45513       };
45514     } catch (...) {
45515       {
45516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45517       };
45518     }
45519   }
45520
45521   jresult = (int)result;
45522   return jresult;
45523 }
45524
45525
45526 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BufferImage_Update__SWIG_0(void * jarg1) {
45527   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45528
45529   arg1 = (Dali::BufferImage *)jarg1;
45530   {
45531     try {
45532       (arg1)->Update();
45533     } catch (std::out_of_range& e) {
45534       {
45535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45536       };
45537     } catch (std::exception& e) {
45538       {
45539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45540       };
45541     } catch (Dali::DaliException e) {
45542       {
45543         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45544       };
45545     } catch (...) {
45546       {
45547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45548       };
45549     }
45550   }
45551
45552 }
45553
45554
45555 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BufferImage_Update__SWIG_1(void * jarg1, void * jarg2) {
45556   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45557   SwigValueWrapper< Dali::Rect< unsigned int > > arg2 ;
45558   Dali::RectArea *argp2 ;
45559
45560   arg1 = (Dali::BufferImage *)jarg1;
45561   argp2 = (Dali::RectArea *)jarg2;
45562   if (!argp2) {
45563     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RectArea", 0);
45564     return ;
45565   }
45566   arg2 = *argp2;
45567   {
45568     try {
45569       (arg1)->Update(arg2);
45570     } catch (std::out_of_range& e) {
45571       {
45572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45573       };
45574     } catch (std::exception& e) {
45575       {
45576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45577       };
45578     } catch (Dali::DaliException e) {
45579       {
45580         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45581       };
45582     } catch (...) {
45583       {
45584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45585       };
45586     }
45587   }
45588
45589 }
45590
45591
45592 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_IsDataExternal(void * jarg1) {
45593   unsigned int jresult ;
45594   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45595   bool result;
45596
45597   arg1 = (Dali::BufferImage *)jarg1;
45598   {
45599     try {
45600       result = (bool)((Dali::BufferImage const *)arg1)->IsDataExternal();
45601     } catch (std::out_of_range& e) {
45602       {
45603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45604       };
45605     } catch (std::exception& e) {
45606       {
45607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45608       };
45609     } catch (Dali::DaliException e) {
45610       {
45611         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45612       };
45613     } catch (...) {
45614       {
45615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45616       };
45617     }
45618   }
45619
45620   jresult = result;
45621   return jresult;
45622 }
45623
45624
45625 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_EncodedBufferImage__SWIG_0() {
45626   void * jresult ;
45627   Dali::EncodedBufferImage *result = 0 ;
45628
45629   {
45630     try {
45631       result = (Dali::EncodedBufferImage *)new Dali::EncodedBufferImage();
45632     } catch (std::out_of_range& e) {
45633       {
45634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45635       };
45636     } catch (std::exception& e) {
45637       {
45638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45639       };
45640     } catch (Dali::DaliException e) {
45641       {
45642         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45643       };
45644     } catch (...) {
45645       {
45646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45647       };
45648     }
45649   }
45650
45651   jresult = (void *)result;
45652   return jresult;
45653 }
45654
45655
45656 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_0(void * jarg1, unsigned long jarg2) {
45657   void * jresult ;
45658   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
45659   std::size_t arg2 ;
45660   Dali::EncodedBufferImage result;
45661
45662   arg1 = (uint8_t *)jarg1;
45663   arg2 = (std::size_t)jarg2;
45664   {
45665     try {
45666       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2);
45667     } catch (std::out_of_range& e) {
45668       {
45669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45670       };
45671     } catch (std::exception& e) {
45672       {
45673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45674       };
45675     } catch (Dali::DaliException e) {
45676       {
45677         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45678       };
45679     } catch (...) {
45680       {
45681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45682       };
45683     }
45684   }
45685
45686   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
45687   return jresult;
45688 }
45689
45690
45691 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
45692   void * jresult ;
45693   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
45694   std::size_t arg2 ;
45695   Dali::ImageDimensions arg3 ;
45696   Dali::FittingMode::Type arg4 ;
45697   Dali::SamplingMode::Type arg5 ;
45698   bool arg6 ;
45699   Dali::ImageDimensions *argp3 ;
45700   Dali::EncodedBufferImage result;
45701
45702   arg1 = (uint8_t *)jarg1;
45703   arg2 = (std::size_t)jarg2;
45704   argp3 = (Dali::ImageDimensions *)jarg3;
45705   if (!argp3) {
45706     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
45707     return 0;
45708   }
45709   arg3 = *argp3;
45710   arg4 = (Dali::FittingMode::Type)jarg4;
45711   arg5 = (Dali::SamplingMode::Type)jarg5;
45712   arg6 = jarg6 ? true : false;
45713   {
45714     try {
45715       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2,arg3,arg4,arg5,arg6);
45716     } catch (std::out_of_range& e) {
45717       {
45718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45719       };
45720     } catch (std::exception& e) {
45721       {
45722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45723       };
45724     } catch (Dali::DaliException e) {
45725       {
45726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45727       };
45728     } catch (...) {
45729       {
45730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45731       };
45732     }
45733   }
45734
45735   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
45736   return jresult;
45737 }
45738
45739
45740 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_2(void * jarg1, unsigned long jarg2, void * jarg3, int jarg4, int jarg5) {
45741   void * jresult ;
45742   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
45743   std::size_t arg2 ;
45744   Dali::ImageDimensions arg3 ;
45745   Dali::FittingMode::Type arg4 ;
45746   Dali::SamplingMode::Type arg5 ;
45747   Dali::ImageDimensions *argp3 ;
45748   Dali::EncodedBufferImage result;
45749
45750   arg1 = (uint8_t *)jarg1;
45751   arg2 = (std::size_t)jarg2;
45752   argp3 = (Dali::ImageDimensions *)jarg3;
45753   if (!argp3) {
45754     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
45755     return 0;
45756   }
45757   arg3 = *argp3;
45758   arg4 = (Dali::FittingMode::Type)jarg4;
45759   arg5 = (Dali::SamplingMode::Type)jarg5;
45760   {
45761     try {
45762       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2,arg3,arg4,arg5);
45763     } catch (std::out_of_range& e) {
45764       {
45765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45766       };
45767     } catch (std::exception& e) {
45768       {
45769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45770       };
45771     } catch (Dali::DaliException e) {
45772       {
45773         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45774       };
45775     } catch (...) {
45776       {
45777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45778       };
45779     }
45780   }
45781
45782   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
45783   return jresult;
45784 }
45785
45786
45787 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_DownCast(void * jarg1) {
45788   void * jresult ;
45789   Dali::BaseHandle arg1 ;
45790   Dali::BaseHandle *argp1 ;
45791   Dali::EncodedBufferImage result;
45792
45793   argp1 = (Dali::BaseHandle *)jarg1;
45794   if (!argp1) {
45795     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
45796     return 0;
45797   }
45798   arg1 = *argp1;
45799   {
45800     try {
45801       result = Dali::EncodedBufferImage::DownCast(arg1);
45802     } catch (std::out_of_range& e) {
45803       {
45804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45805       };
45806     } catch (std::exception& e) {
45807       {
45808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45809       };
45810     } catch (Dali::DaliException e) {
45811       {
45812         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45813       };
45814     } catch (...) {
45815       {
45816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45817       };
45818     }
45819   }
45820
45821   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
45822   return jresult;
45823 }
45824
45825
45826 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_EncodedBufferImage(void * jarg1) {
45827   Dali::EncodedBufferImage *arg1 = (Dali::EncodedBufferImage *) 0 ;
45828
45829   arg1 = (Dali::EncodedBufferImage *)jarg1;
45830   {
45831     try {
45832       delete arg1;
45833     } catch (std::out_of_range& e) {
45834       {
45835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45836       };
45837     } catch (std::exception& e) {
45838       {
45839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45840       };
45841     } catch (Dali::DaliException e) {
45842       {
45843         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45844       };
45845     } catch (...) {
45846       {
45847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45848       };
45849     }
45850   }
45851
45852 }
45853
45854
45855 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_EncodedBufferImage__SWIG_1(void * jarg1) {
45856   void * jresult ;
45857   Dali::EncodedBufferImage *arg1 = 0 ;
45858   Dali::EncodedBufferImage *result = 0 ;
45859
45860   arg1 = (Dali::EncodedBufferImage *)jarg1;
45861   if (!arg1) {
45862     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::EncodedBufferImage const & type is null", 0);
45863     return 0;
45864   }
45865   {
45866     try {
45867       result = (Dali::EncodedBufferImage *)new Dali::EncodedBufferImage((Dali::EncodedBufferImage const &)*arg1);
45868     } catch (std::out_of_range& e) {
45869       {
45870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45871       };
45872     } catch (std::exception& e) {
45873       {
45874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45875       };
45876     } catch (Dali::DaliException e) {
45877       {
45878         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45879       };
45880     } catch (...) {
45881       {
45882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45883       };
45884     }
45885   }
45886
45887   jresult = (void *)result;
45888   return jresult;
45889 }
45890
45891
45892 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_Assign(void * jarg1, void * jarg2) {
45893   void * jresult ;
45894   Dali::EncodedBufferImage *arg1 = (Dali::EncodedBufferImage *) 0 ;
45895   Dali::EncodedBufferImage *arg2 = 0 ;
45896   Dali::EncodedBufferImage *result = 0 ;
45897
45898   arg1 = (Dali::EncodedBufferImage *)jarg1;
45899   arg2 = (Dali::EncodedBufferImage *)jarg2;
45900   if (!arg2) {
45901     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::EncodedBufferImage const & type is null", 0);
45902     return 0;
45903   }
45904   {
45905     try {
45906       result = (Dali::EncodedBufferImage *) &(arg1)->operator =((Dali::EncodedBufferImage const &)*arg2);
45907     } catch (std::out_of_range& e) {
45908       {
45909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45910       };
45911     } catch (std::exception& e) {
45912       {
45913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45914       };
45915     } catch (Dali::DaliException e) {
45916       {
45917         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45918       };
45919     } catch (...) {
45920       {
45921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45922       };
45923     }
45924   }
45925
45926   jresult = (void *)result;
45927   return jresult;
45928 }
45929
45930
45931 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NativeImage__SWIG_0() {
45932   void * jresult ;
45933   Dali::NativeImage *result = 0 ;
45934
45935   {
45936     try {
45937       result = (Dali::NativeImage *)new Dali::NativeImage();
45938     } catch (std::out_of_range& e) {
45939       {
45940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45941       };
45942     } catch (std::exception& e) {
45943       {
45944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45945       };
45946     } catch (Dali::DaliException e) {
45947       {
45948         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45949       };
45950     } catch (...) {
45951       {
45952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45953       };
45954     }
45955   }
45956
45957   jresult = (void *)result;
45958   return jresult;
45959 }
45960
45961
45962 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_NativeImage(void * jarg1) {
45963   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
45964
45965   arg1 = (Dali::NativeImage *)jarg1;
45966   {
45967     try {
45968       delete arg1;
45969     } catch (std::out_of_range& e) {
45970       {
45971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45972       };
45973     } catch (std::exception& e) {
45974       {
45975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45976       };
45977     } catch (Dali::DaliException e) {
45978       {
45979         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45980       };
45981     } catch (...) {
45982       {
45983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45984       };
45985     }
45986   }
45987
45988 }
45989
45990
45991 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NativeImage__SWIG_1(void * jarg1) {
45992   void * jresult ;
45993   Dali::NativeImage *arg1 = 0 ;
45994   Dali::NativeImage *result = 0 ;
45995
45996   arg1 = (Dali::NativeImage *)jarg1;
45997   if (!arg1) {
45998     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImage const & type is null", 0);
45999     return 0;
46000   }
46001   {
46002     try {
46003       result = (Dali::NativeImage *)new Dali::NativeImage((Dali::NativeImage const &)*arg1);
46004     } catch (std::out_of_range& e) {
46005       {
46006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46007       };
46008     } catch (std::exception& e) {
46009       {
46010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46011       };
46012     } catch (Dali::DaliException e) {
46013       {
46014         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46015       };
46016     } catch (...) {
46017       {
46018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46019       };
46020     }
46021   }
46022
46023   jresult = (void *)result;
46024   return jresult;
46025 }
46026
46027
46028 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_Assign(void * jarg1, void * jarg2) {
46029   void * jresult ;
46030   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
46031   Dali::NativeImage *arg2 = 0 ;
46032   Dali::NativeImage *result = 0 ;
46033
46034   arg1 = (Dali::NativeImage *)jarg1;
46035   arg2 = (Dali::NativeImage *)jarg2;
46036   if (!arg2) {
46037     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImage const & type is null", 0);
46038     return 0;
46039   }
46040   {
46041     try {
46042       result = (Dali::NativeImage *) &(arg1)->operator =((Dali::NativeImage const &)*arg2);
46043     } catch (std::out_of_range& e) {
46044       {
46045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46046       };
46047     } catch (std::exception& e) {
46048       {
46049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46050       };
46051     } catch (Dali::DaliException e) {
46052       {
46053         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46054       };
46055     } catch (...) {
46056       {
46057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46058       };
46059     }
46060   }
46061
46062   jresult = (void *)result;
46063   return jresult;
46064 }
46065
46066
46067 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImage_CreateGlTexture(void * jarg1) {
46068   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
46069
46070   arg1 = (Dali::NativeImage *)jarg1;
46071   {
46072     try {
46073       (arg1)->CreateGlTexture();
46074     } catch (std::out_of_range& e) {
46075       {
46076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46077       };
46078     } catch (std::exception& e) {
46079       {
46080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46081       };
46082     } catch (Dali::DaliException e) {
46083       {
46084         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46085       };
46086     } catch (...) {
46087       {
46088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46089       };
46090     }
46091   }
46092
46093 }
46094
46095
46096 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_New(void * jarg1) {
46097   void * jresult ;
46098   NativeImageInterface *arg1 = 0 ;
46099   Dali::NativeImage result;
46100
46101   arg1 = (NativeImageInterface *)jarg1;
46102   if (!arg1) {
46103     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
46104     return 0;
46105   }
46106   {
46107     try {
46108       result = Dali::NativeImage::New(*arg1);
46109     } catch (std::out_of_range& e) {
46110       {
46111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46112       };
46113     } catch (std::exception& e) {
46114       {
46115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46116       };
46117     } catch (Dali::DaliException e) {
46118       {
46119         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46120       };
46121     } catch (...) {
46122       {
46123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46124       };
46125     }
46126   }
46127
46128   jresult = new Dali::NativeImage((const Dali::NativeImage &)result);
46129   return jresult;
46130 }
46131
46132
46133 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_DownCast(void * jarg1) {
46134   void * jresult ;
46135   Dali::BaseHandle arg1 ;
46136   Dali::BaseHandle *argp1 ;
46137   Dali::NativeImage result;
46138
46139   argp1 = (Dali::BaseHandle *)jarg1;
46140   if (!argp1) {
46141     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
46142     return 0;
46143   }
46144   arg1 = *argp1;
46145   {
46146     try {
46147       result = Dali::NativeImage::DownCast(arg1);
46148     } catch (std::out_of_range& e) {
46149       {
46150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46151       };
46152     } catch (std::exception& e) {
46153       {
46154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46155       };
46156     } catch (Dali::DaliException e) {
46157       {
46158         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46159       };
46160     } catch (...) {
46161       {
46162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46163       };
46164     }
46165   }
46166
46167   jresult = new Dali::NativeImage((const Dali::NativeImage &)result);
46168   return jresult;
46169 }
46170
46171
46172 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_NativeImage_GetCustomFragmentPreFix(void * jarg1) {
46173   char * jresult ;
46174   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
46175   char *result = 0 ;
46176
46177   arg1 = (Dali::NativeImage *)jarg1;
46178   {
46179     try {
46180       result = (char *)(arg1)->GetCustomFragmentPreFix();
46181     } catch (std::out_of_range& e) {
46182       {
46183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46184       };
46185     } catch (std::exception& e) {
46186       {
46187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46188       };
46189     } catch (Dali::DaliException e) {
46190       {
46191         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46192       };
46193     } catch (...) {
46194       {
46195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46196       };
46197     }
46198   }
46199
46200   jresult = SWIG_csharp_string_callback((const char *)result);
46201   return jresult;
46202 }
46203
46204
46205 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_NativeImage_GetCustomSamplerTypename(void * jarg1) {
46206   char * jresult ;
46207   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
46208   char *result = 0 ;
46209
46210   arg1 = (Dali::NativeImage *)jarg1;
46211   {
46212     try {
46213       result = (char *)(arg1)->GetCustomSamplerTypename();
46214     } catch (std::out_of_range& e) {
46215       {
46216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46217       };
46218     } catch (std::exception& e) {
46219       {
46220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46221       };
46222     } catch (Dali::DaliException e) {
46223       {
46224         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46225       };
46226     } catch (...) {
46227       {
46228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46229       };
46230     }
46231   }
46232
46233   jresult = SWIG_csharp_string_callback((const char *)result);
46234   return jresult;
46235 }
46236
46237
46238 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GlExtensionCreate(void * jarg1) {
46239   unsigned int jresult ;
46240   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46241   bool result;
46242
46243   arg1 = (Dali::NativeImageInterface *)jarg1;
46244   {
46245     try {
46246       result = (bool)(arg1)->GlExtensionCreate();
46247     } catch (std::out_of_range& e) {
46248       {
46249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46250       };
46251     } catch (std::exception& e) {
46252       {
46253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46254       };
46255     } catch (Dali::DaliException e) {
46256       {
46257         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46258       };
46259     } catch (...) {
46260       {
46261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46262       };
46263     }
46264   }
46265
46266   jresult = result;
46267   return jresult;
46268 }
46269
46270
46271 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_GlExtensionDestroy(void * jarg1) {
46272   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46273
46274   arg1 = (Dali::NativeImageInterface *)jarg1;
46275   {
46276     try {
46277       (arg1)->GlExtensionDestroy();
46278     } catch (std::out_of_range& e) {
46279       {
46280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46281       };
46282     } catch (std::exception& e) {
46283       {
46284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46285       };
46286     } catch (Dali::DaliException e) {
46287       {
46288         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46289       };
46290     } catch (...) {
46291       {
46292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46293       };
46294     }
46295   }
46296
46297 }
46298
46299
46300 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_TargetTexture(void * jarg1) {
46301   unsigned int jresult ;
46302   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46303   unsigned int result;
46304
46305   arg1 = (Dali::NativeImageInterface *)jarg1;
46306   {
46307     try {
46308       result = (unsigned int)(arg1)->TargetTexture();
46309     } catch (std::out_of_range& e) {
46310       {
46311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46312       };
46313     } catch (std::exception& e) {
46314       {
46315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46316       };
46317     } catch (Dali::DaliException e) {
46318       {
46319         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46320       };
46321     } catch (...) {
46322       {
46323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46324       };
46325     }
46326   }
46327
46328   jresult = result;
46329   return jresult;
46330 }
46331
46332
46333 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_PrepareTexture(void * jarg1) {
46334   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46335
46336   arg1 = (Dali::NativeImageInterface *)jarg1;
46337   {
46338     try {
46339       (arg1)->PrepareTexture();
46340     } catch (std::out_of_range& e) {
46341       {
46342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46343       };
46344     } catch (std::exception& e) {
46345       {
46346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46347       };
46348     } catch (Dali::DaliException e) {
46349       {
46350         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46351       };
46352     } catch (...) {
46353       {
46354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46355       };
46356     }
46357   }
46358
46359 }
46360
46361
46362 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetWidth(void * jarg1) {
46363   unsigned int jresult ;
46364   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46365   unsigned int result;
46366
46367   arg1 = (Dali::NativeImageInterface *)jarg1;
46368   {
46369     try {
46370       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetWidth();
46371     } catch (std::out_of_range& e) {
46372       {
46373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46374       };
46375     } catch (std::exception& e) {
46376       {
46377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46378       };
46379     } catch (Dali::DaliException e) {
46380       {
46381         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46382       };
46383     } catch (...) {
46384       {
46385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46386       };
46387     }
46388   }
46389
46390   jresult = result;
46391   return jresult;
46392 }
46393
46394
46395 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetHeight(void * jarg1) {
46396   unsigned int jresult ;
46397   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46398   unsigned int result;
46399
46400   arg1 = (Dali::NativeImageInterface *)jarg1;
46401   {
46402     try {
46403       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetHeight();
46404     } catch (std::out_of_range& e) {
46405       {
46406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46407       };
46408     } catch (std::exception& e) {
46409       {
46410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46411       };
46412     } catch (Dali::DaliException e) {
46413       {
46414         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46415       };
46416     } catch (...) {
46417       {
46418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46419       };
46420     }
46421   }
46422
46423   jresult = result;
46424   return jresult;
46425 }
46426
46427
46428 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_RequiresBlending(void * jarg1) {
46429   unsigned int jresult ;
46430   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46431   bool result;
46432
46433   arg1 = (Dali::NativeImageInterface *)jarg1;
46434   {
46435     try {
46436       result = (bool)((Dali::NativeImageInterface const *)arg1)->RequiresBlending();
46437     } catch (std::out_of_range& e) {
46438       {
46439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46440       };
46441     } catch (std::exception& e) {
46442       {
46443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46444       };
46445     } catch (Dali::DaliException e) {
46446       {
46447         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46448       };
46449     } catch (...) {
46450       {
46451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46452       };
46453     }
46454   }
46455
46456   jresult = result;
46457   return jresult;
46458 }
46459
46460
46461 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_GetImageSize(char * jarg1) {
46462   void * jresult ;
46463   std::string *arg1 = 0 ;
46464   Dali::ImageDimensions result;
46465
46466   if (!jarg1) {
46467     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46468     return 0;
46469   }
46470   std::string arg1_str(jarg1);
46471   arg1 = &arg1_str;
46472   {
46473     try {
46474       result = Dali::ResourceImage::GetImageSize((std::string const &)*arg1);
46475     } catch (std::out_of_range& e) {
46476       {
46477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46478       };
46479     } catch (std::exception& e) {
46480       {
46481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46482       };
46483     } catch (Dali::DaliException e) {
46484       {
46485         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46486       };
46487     } catch (...) {
46488       {
46489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46490       };
46491     }
46492   }
46493
46494   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
46495
46496   //argout typemap for const std::string&
46497
46498   return jresult;
46499 }
46500
46501
46502 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImage__SWIG_0() {
46503   void * jresult ;
46504   Dali::ResourceImage *result = 0 ;
46505
46506   {
46507     try {
46508       result = (Dali::ResourceImage *)new Dali::ResourceImage();
46509     } catch (std::out_of_range& e) {
46510       {
46511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46512       };
46513     } catch (std::exception& e) {
46514       {
46515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46516       };
46517     } catch (Dali::DaliException e) {
46518       {
46519         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46520       };
46521     } catch (...) {
46522       {
46523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46524       };
46525     }
46526   }
46527
46528   jresult = (void *)result;
46529   return jresult;
46530 }
46531
46532
46533 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ResourceImage(void * jarg1) {
46534   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
46535
46536   arg1 = (Dali::ResourceImage *)jarg1;
46537   {
46538     try {
46539       delete arg1;
46540     } catch (std::out_of_range& e) {
46541       {
46542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46543       };
46544     } catch (std::exception& e) {
46545       {
46546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46547       };
46548     } catch (Dali::DaliException e) {
46549       {
46550         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46551       };
46552     } catch (...) {
46553       {
46554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46555       };
46556     }
46557   }
46558
46559 }
46560
46561
46562 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImage__SWIG_1(void * jarg1) {
46563   void * jresult ;
46564   Dali::ResourceImage *arg1 = 0 ;
46565   Dali::ResourceImage *result = 0 ;
46566
46567   arg1 = (Dali::ResourceImage *)jarg1;
46568   if (!arg1) {
46569     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ResourceImage const & type is null", 0);
46570     return 0;
46571   }
46572   {
46573     try {
46574       result = (Dali::ResourceImage *)new Dali::ResourceImage((Dali::ResourceImage const &)*arg1);
46575     } catch (std::out_of_range& e) {
46576       {
46577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46578       };
46579     } catch (std::exception& e) {
46580       {
46581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46582       };
46583     } catch (Dali::DaliException e) {
46584       {
46585         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46586       };
46587     } catch (...) {
46588       {
46589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46590       };
46591     }
46592   }
46593
46594   jresult = (void *)result;
46595   return jresult;
46596 }
46597
46598
46599 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_Assign(void * jarg1, void * jarg2) {
46600   void * jresult ;
46601   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
46602   Dali::ResourceImage *arg2 = 0 ;
46603   Dali::ResourceImage *result = 0 ;
46604
46605   arg1 = (Dali::ResourceImage *)jarg1;
46606   arg2 = (Dali::ResourceImage *)jarg2;
46607   if (!arg2) {
46608     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ResourceImage const & type is null", 0);
46609     return 0;
46610   }
46611   {
46612     try {
46613       result = (Dali::ResourceImage *) &(arg1)->operator =((Dali::ResourceImage const &)*arg2);
46614     } catch (std::out_of_range& e) {
46615       {
46616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46617       };
46618     } catch (std::exception& e) {
46619       {
46620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46621       };
46622     } catch (Dali::DaliException e) {
46623       {
46624         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46625       };
46626     } catch (...) {
46627       {
46628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46629       };
46630     }
46631   }
46632
46633   jresult = (void *)result;
46634   return jresult;
46635 }
46636
46637
46638 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_0(char * jarg1, unsigned int jarg2) {
46639   void * jresult ;
46640   std::string *arg1 = 0 ;
46641   bool arg2 ;
46642   Dali::ResourceImage result;
46643
46644   if (!jarg1) {
46645     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46646     return 0;
46647   }
46648   std::string arg1_str(jarg1);
46649   arg1 = &arg1_str;
46650   arg2 = jarg2 ? true : false;
46651   {
46652     try {
46653       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2);
46654     } catch (std::out_of_range& e) {
46655       {
46656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46657       };
46658     } catch (std::exception& e) {
46659       {
46660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46661       };
46662     } catch (Dali::DaliException e) {
46663       {
46664         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46665       };
46666     } catch (...) {
46667       {
46668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46669       };
46670     }
46671   }
46672
46673   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46674
46675   //argout typemap for const std::string&
46676
46677   return jresult;
46678 }
46679
46680
46681 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_1(char * jarg1) {
46682   void * jresult ;
46683   std::string *arg1 = 0 ;
46684   Dali::ResourceImage result;
46685
46686   if (!jarg1) {
46687     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46688     return 0;
46689   }
46690   std::string arg1_str(jarg1);
46691   arg1 = &arg1_str;
46692   {
46693     try {
46694       result = Dali::ResourceImage::New((std::string const &)*arg1);
46695     } catch (std::out_of_range& e) {
46696       {
46697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46698       };
46699     } catch (std::exception& e) {
46700       {
46701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46702       };
46703     } catch (Dali::DaliException e) {
46704       {
46705         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46706       };
46707     } catch (...) {
46708       {
46709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46710       };
46711     }
46712   }
46713
46714   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46715
46716   //argout typemap for const std::string&
46717
46718   return jresult;
46719 }
46720
46721
46722 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
46723   void * jresult ;
46724   std::string *arg1 = 0 ;
46725   Dali::ImageDimensions arg2 ;
46726   Dali::FittingMode::Type arg3 ;
46727   Dali::SamplingMode::Type arg4 ;
46728   bool arg5 ;
46729   Dali::ImageDimensions *argp2 ;
46730   Dali::ResourceImage result;
46731
46732   if (!jarg1) {
46733     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46734     return 0;
46735   }
46736   std::string arg1_str(jarg1);
46737   arg1 = &arg1_str;
46738   argp2 = (Dali::ImageDimensions *)jarg2;
46739   if (!argp2) {
46740     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
46741     return 0;
46742   }
46743   arg2 = *argp2;
46744   arg3 = (Dali::FittingMode::Type)jarg3;
46745   arg4 = (Dali::SamplingMode::Type)jarg4;
46746   arg5 = jarg5 ? true : false;
46747   {
46748     try {
46749       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3,arg4,arg5);
46750     } catch (std::out_of_range& e) {
46751       {
46752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46753       };
46754     } catch (std::exception& e) {
46755       {
46756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46757       };
46758     } catch (Dali::DaliException e) {
46759       {
46760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46761       };
46762     } catch (...) {
46763       {
46764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46765       };
46766     }
46767   }
46768
46769   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46770
46771   //argout typemap for const std::string&
46772
46773   return jresult;
46774 }
46775
46776
46777 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_3(char * jarg1, void * jarg2, int jarg3, int jarg4) {
46778   void * jresult ;
46779   std::string *arg1 = 0 ;
46780   Dali::ImageDimensions arg2 ;
46781   Dali::FittingMode::Type arg3 ;
46782   Dali::SamplingMode::Type arg4 ;
46783   Dali::ImageDimensions *argp2 ;
46784   Dali::ResourceImage result;
46785
46786   if (!jarg1) {
46787     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46788     return 0;
46789   }
46790   std::string arg1_str(jarg1);
46791   arg1 = &arg1_str;
46792   argp2 = (Dali::ImageDimensions *)jarg2;
46793   if (!argp2) {
46794     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
46795     return 0;
46796   }
46797   arg2 = *argp2;
46798   arg3 = (Dali::FittingMode::Type)jarg3;
46799   arg4 = (Dali::SamplingMode::Type)jarg4;
46800   {
46801     try {
46802       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3,arg4);
46803     } catch (std::out_of_range& e) {
46804       {
46805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46806       };
46807     } catch (std::exception& e) {
46808       {
46809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46810       };
46811     } catch (Dali::DaliException e) {
46812       {
46813         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46814       };
46815     } catch (...) {
46816       {
46817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46818       };
46819     }
46820   }
46821
46822   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46823
46824   //argout typemap for const std::string&
46825
46826   return jresult;
46827 }
46828
46829
46830 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_4(char * jarg1, void * jarg2, int jarg3) {
46831   void * jresult ;
46832   std::string *arg1 = 0 ;
46833   Dali::ImageDimensions arg2 ;
46834   Dali::FittingMode::Type arg3 ;
46835   Dali::ImageDimensions *argp2 ;
46836   Dali::ResourceImage result;
46837
46838   if (!jarg1) {
46839     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46840     return 0;
46841   }
46842   std::string arg1_str(jarg1);
46843   arg1 = &arg1_str;
46844   argp2 = (Dali::ImageDimensions *)jarg2;
46845   if (!argp2) {
46846     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
46847     return 0;
46848   }
46849   arg2 = *argp2;
46850   arg3 = (Dali::FittingMode::Type)jarg3;
46851   {
46852     try {
46853       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3);
46854     } catch (std::out_of_range& e) {
46855       {
46856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46857       };
46858     } catch (std::exception& e) {
46859       {
46860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46861       };
46862     } catch (Dali::DaliException e) {
46863       {
46864         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46865       };
46866     } catch (...) {
46867       {
46868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46869       };
46870     }
46871   }
46872
46873   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46874
46875   //argout typemap for const std::string&
46876
46877   return jresult;
46878 }
46879
46880
46881 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_5(char * jarg1, void * jarg2) {
46882   void * jresult ;
46883   std::string *arg1 = 0 ;
46884   Dali::ImageDimensions arg2 ;
46885   Dali::ImageDimensions *argp2 ;
46886   Dali::ResourceImage result;
46887
46888   if (!jarg1) {
46889     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46890     return 0;
46891   }
46892   std::string arg1_str(jarg1);
46893   arg1 = &arg1_str;
46894   argp2 = (Dali::ImageDimensions *)jarg2;
46895   if (!argp2) {
46896     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
46897     return 0;
46898   }
46899   arg2 = *argp2;
46900   {
46901     try {
46902       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2);
46903     } catch (std::out_of_range& e) {
46904       {
46905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46906       };
46907     } catch (std::exception& e) {
46908       {
46909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46910       };
46911     } catch (Dali::DaliException e) {
46912       {
46913         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46914       };
46915     } catch (...) {
46916       {
46917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46918       };
46919     }
46920   }
46921
46922   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46923
46924   //argout typemap for const std::string&
46925
46926   return jresult;
46927 }
46928
46929
46930 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_DownCast(void * jarg1) {
46931   void * jresult ;
46932   Dali::BaseHandle arg1 ;
46933   Dali::BaseHandle *argp1 ;
46934   Dali::ResourceImage result;
46935
46936   argp1 = (Dali::BaseHandle *)jarg1;
46937   if (!argp1) {
46938     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
46939     return 0;
46940   }
46941   arg1 = *argp1;
46942   {
46943     try {
46944       result = Dali::ResourceImage::DownCast(arg1);
46945     } catch (std::out_of_range& e) {
46946       {
46947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46948       };
46949     } catch (std::exception& e) {
46950       {
46951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46952       };
46953     } catch (Dali::DaliException e) {
46954       {
46955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46956       };
46957     } catch (...) {
46958       {
46959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46960       };
46961     }
46962   }
46963
46964   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46965   return jresult;
46966 }
46967
46968
46969 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ResourceImage_GetLoadingState(void * jarg1) {
46970   int jresult ;
46971   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
46972   Dali::LoadingState result;
46973
46974   arg1 = (Dali::ResourceImage *)jarg1;
46975   {
46976     try {
46977       result = (Dali::LoadingState)((Dali::ResourceImage const *)arg1)->GetLoadingState();
46978     } catch (std::out_of_range& e) {
46979       {
46980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46981       };
46982     } catch (std::exception& e) {
46983       {
46984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46985       };
46986     } catch (Dali::DaliException e) {
46987       {
46988         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46989       };
46990     } catch (...) {
46991       {
46992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46993       };
46994     }
46995   }
46996
46997   jresult = (int)result;
46998   return jresult;
46999 }
47000
47001
47002 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ResourceImage_GetUrl(void * jarg1) {
47003   char * jresult ;
47004   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
47005   std::string result;
47006
47007   arg1 = (Dali::ResourceImage *)jarg1;
47008   {
47009     try {
47010       result = ((Dali::ResourceImage const *)arg1)->GetUrl();
47011     } catch (std::out_of_range& e) {
47012       {
47013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47014       };
47015     } catch (std::exception& e) {
47016       {
47017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47018       };
47019     } catch (Dali::DaliException e) {
47020       {
47021         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47022       };
47023     } catch (...) {
47024       {
47025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47026       };
47027     }
47028   }
47029
47030   jresult = SWIG_csharp_string_callback((&result)->c_str());
47031   return jresult;
47032 }
47033
47034
47035 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImage_Reload(void * jarg1) {
47036   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
47037
47038   arg1 = (Dali::ResourceImage *)jarg1;
47039   {
47040     try {
47041       (arg1)->Reload();
47042     } catch (std::out_of_range& e) {
47043       {
47044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47045       };
47046     } catch (std::exception& e) {
47047       {
47048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47049       };
47050     } catch (Dali::DaliException e) {
47051       {
47052         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47053       };
47054     } catch (...) {
47055       {
47056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47057       };
47058     }
47059   }
47060
47061 }
47062
47063
47064 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_LoadingFinishedSignal(void * jarg1) {
47065   void * jresult ;
47066   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
47067   Dali::ResourceImage::ResourceImageSignal *result = 0 ;
47068
47069   arg1 = (Dali::ResourceImage *)jarg1;
47070   {
47071     try {
47072       result = (Dali::ResourceImage::ResourceImageSignal *) &(arg1)->LoadingFinishedSignal();
47073     } catch (std::out_of_range& e) {
47074       {
47075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47076       };
47077     } catch (std::exception& e) {
47078       {
47079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47080       };
47081     } catch (Dali::DaliException e) {
47082       {
47083         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47084       };
47085     } catch (...) {
47086       {
47087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47088       };
47089     }
47090   }
47091
47092   jresult = (void *)result;
47093   return jresult;
47094 }
47095
47096
47097 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBufferImage__SWIG_0() {
47098   void * jresult ;
47099   Dali::FrameBufferImage *result = 0 ;
47100
47101   {
47102     try {
47103       result = (Dali::FrameBufferImage *)new Dali::FrameBufferImage();
47104     } catch (std::out_of_range& e) {
47105       {
47106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47107       };
47108     } catch (std::exception& e) {
47109       {
47110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47111       };
47112     } catch (Dali::DaliException e) {
47113       {
47114         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47115       };
47116     } catch (...) {
47117       {
47118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47119       };
47120     }
47121   }
47122
47123   jresult = (void *)result;
47124   return jresult;
47125 }
47126
47127
47128 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_0(unsigned int jarg1, unsigned int jarg2, int jarg3, int jarg4) {
47129   void * jresult ;
47130   unsigned int arg1 ;
47131   unsigned int arg2 ;
47132   Dali::Pixel::Format arg3 ;
47133   Dali::RenderBuffer::Format arg4 ;
47134   Dali::FrameBufferImage result;
47135
47136   arg1 = (unsigned int)jarg1;
47137   arg2 = (unsigned int)jarg2;
47138   arg3 = (Dali::Pixel::Format)jarg3;
47139   arg4 = (Dali::RenderBuffer::Format)jarg4;
47140   {
47141     try {
47142       result = Dali::FrameBufferImage::New(arg1,arg2,arg3,arg4);
47143     } catch (std::out_of_range& e) {
47144       {
47145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47146       };
47147     } catch (std::exception& e) {
47148       {
47149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47150       };
47151     } catch (Dali::DaliException e) {
47152       {
47153         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47154       };
47155     } catch (...) {
47156       {
47157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47158       };
47159     }
47160   }
47161
47162   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47163   return jresult;
47164 }
47165
47166
47167 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_1(unsigned int jarg1, unsigned int jarg2, int jarg3) {
47168   void * jresult ;
47169   unsigned int arg1 ;
47170   unsigned int arg2 ;
47171   Dali::Pixel::Format arg3 ;
47172   Dali::FrameBufferImage result;
47173
47174   arg1 = (unsigned int)jarg1;
47175   arg2 = (unsigned int)jarg2;
47176   arg3 = (Dali::Pixel::Format)jarg3;
47177   {
47178     try {
47179       result = Dali::FrameBufferImage::New(arg1,arg2,arg3);
47180     } catch (std::out_of_range& e) {
47181       {
47182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47183       };
47184     } catch (std::exception& e) {
47185       {
47186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47187       };
47188     } catch (Dali::DaliException e) {
47189       {
47190         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47191       };
47192     } catch (...) {
47193       {
47194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47195       };
47196     }
47197   }
47198
47199   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47200   return jresult;
47201 }
47202
47203
47204 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
47205   void * jresult ;
47206   unsigned int arg1 ;
47207   unsigned int arg2 ;
47208   Dali::FrameBufferImage result;
47209
47210   arg1 = (unsigned int)jarg1;
47211   arg2 = (unsigned int)jarg2;
47212   {
47213     try {
47214       result = Dali::FrameBufferImage::New(arg1,arg2);
47215     } catch (std::out_of_range& e) {
47216       {
47217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47218       };
47219     } catch (std::exception& e) {
47220       {
47221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47222       };
47223     } catch (Dali::DaliException e) {
47224       {
47225         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47226       };
47227     } catch (...) {
47228       {
47229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47230       };
47231     }
47232   }
47233
47234   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47235   return jresult;
47236 }
47237
47238
47239 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_3(unsigned int jarg1) {
47240   void * jresult ;
47241   unsigned int arg1 ;
47242   Dali::FrameBufferImage result;
47243
47244   arg1 = (unsigned int)jarg1;
47245   {
47246     try {
47247       result = Dali::FrameBufferImage::New(arg1);
47248     } catch (std::out_of_range& e) {
47249       {
47250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47251       };
47252     } catch (std::exception& e) {
47253       {
47254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47255       };
47256     } catch (Dali::DaliException e) {
47257       {
47258         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47259       };
47260     } catch (...) {
47261       {
47262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47263       };
47264     }
47265   }
47266
47267   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47268   return jresult;
47269 }
47270
47271
47272 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_4() {
47273   void * jresult ;
47274   Dali::FrameBufferImage result;
47275
47276   {
47277     try {
47278       result = Dali::FrameBufferImage::New();
47279     } catch (std::out_of_range& e) {
47280       {
47281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47282       };
47283     } catch (std::exception& e) {
47284       {
47285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47286       };
47287     } catch (Dali::DaliException e) {
47288       {
47289         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47290       };
47291     } catch (...) {
47292       {
47293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47294       };
47295     }
47296   }
47297
47298   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47299   return jresult;
47300 }
47301
47302
47303 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_5(void * jarg1) {
47304   void * jresult ;
47305   Dali::NativeImageInterface *arg1 = 0 ;
47306   Dali::FrameBufferImage result;
47307
47308   arg1 = (Dali::NativeImageInterface *)jarg1;
47309   if (!arg1) {
47310     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImageInterface & type is null", 0);
47311     return 0;
47312   }
47313   {
47314     try {
47315       result = Dali::FrameBufferImage::New(*arg1);
47316     } catch (std::out_of_range& e) {
47317       {
47318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47319       };
47320     } catch (std::exception& e) {
47321       {
47322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47323       };
47324     } catch (Dali::DaliException e) {
47325       {
47326         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47327       };
47328     } catch (...) {
47329       {
47330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47331       };
47332     }
47333   }
47334
47335   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47336   return jresult;
47337 }
47338
47339
47340 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_DownCast(void * jarg1) {
47341   void * jresult ;
47342   Dali::BaseHandle arg1 ;
47343   Dali::BaseHandle *argp1 ;
47344   Dali::FrameBufferImage result;
47345
47346   argp1 = (Dali::BaseHandle *)jarg1;
47347   if (!argp1) {
47348     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
47349     return 0;
47350   }
47351   arg1 = *argp1;
47352   {
47353     try {
47354       result = Dali::FrameBufferImage::DownCast(arg1);
47355     } catch (std::out_of_range& e) {
47356       {
47357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47358       };
47359     } catch (std::exception& e) {
47360       {
47361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47362       };
47363     } catch (Dali::DaliException e) {
47364       {
47365         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47366       };
47367     } catch (...) {
47368       {
47369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47370       };
47371     }
47372   }
47373
47374   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47375   return jresult;
47376 }
47377
47378
47379 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBufferImage(void * jarg1) {
47380   Dali::FrameBufferImage *arg1 = (Dali::FrameBufferImage *) 0 ;
47381
47382   arg1 = (Dali::FrameBufferImage *)jarg1;
47383   {
47384     try {
47385       delete arg1;
47386     } catch (std::out_of_range& e) {
47387       {
47388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47389       };
47390     } catch (std::exception& e) {
47391       {
47392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47393       };
47394     } catch (Dali::DaliException e) {
47395       {
47396         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47397       };
47398     } catch (...) {
47399       {
47400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47401       };
47402     }
47403   }
47404
47405 }
47406
47407
47408 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBufferImage__SWIG_1(void * jarg1) {
47409   void * jresult ;
47410   Dali::FrameBufferImage *arg1 = 0 ;
47411   Dali::FrameBufferImage *result = 0 ;
47412
47413   arg1 = (Dali::FrameBufferImage *)jarg1;
47414   if (!arg1) {
47415     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBufferImage const & type is null", 0);
47416     return 0;
47417   }
47418   {
47419     try {
47420       result = (Dali::FrameBufferImage *)new Dali::FrameBufferImage((Dali::FrameBufferImage const &)*arg1);
47421     } catch (std::out_of_range& e) {
47422       {
47423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47424       };
47425     } catch (std::exception& e) {
47426       {
47427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47428       };
47429     } catch (Dali::DaliException e) {
47430       {
47431         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47432       };
47433     } catch (...) {
47434       {
47435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47436       };
47437     }
47438   }
47439
47440   jresult = (void *)result;
47441   return jresult;
47442 }
47443
47444
47445 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_Assign(void * jarg1, void * jarg2) {
47446   void * jresult ;
47447   Dali::FrameBufferImage *arg1 = (Dali::FrameBufferImage *) 0 ;
47448   Dali::FrameBufferImage *arg2 = 0 ;
47449   Dali::FrameBufferImage *result = 0 ;
47450
47451   arg1 = (Dali::FrameBufferImage *)jarg1;
47452   arg2 = (Dali::FrameBufferImage *)jarg2;
47453   if (!arg2) {
47454     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBufferImage const & type is null", 0);
47455     return 0;
47456   }
47457   {
47458     try {
47459       result = (Dali::FrameBufferImage *) &(arg1)->operator =((Dali::FrameBufferImage const &)*arg2);
47460     } catch (std::out_of_range& e) {
47461       {
47462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47463       };
47464     } catch (std::exception& e) {
47465       {
47466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47467       };
47468     } catch (Dali::DaliException e) {
47469       {
47470         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47471       };
47472     } catch (...) {
47473       {
47474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47475       };
47476     }
47477   }
47478
47479   jresult = (void *)result;
47480   return jresult;
47481 }
47482
47483
47484 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NinePatchImage__SWIG_0() {
47485   void * jresult ;
47486   Dali::NinePatchImage *result = 0 ;
47487
47488   {
47489     try {
47490       result = (Dali::NinePatchImage *)new Dali::NinePatchImage();
47491     } catch (std::out_of_range& e) {
47492       {
47493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47494       };
47495     } catch (std::exception& e) {
47496       {
47497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47498       };
47499     } catch (Dali::DaliException e) {
47500       {
47501         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47502       };
47503     } catch (...) {
47504       {
47505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47506       };
47507     }
47508   }
47509
47510   jresult = (void *)result;
47511   return jresult;
47512 }
47513
47514
47515 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_New(char * jarg1) {
47516   void * jresult ;
47517   std::string *arg1 = 0 ;
47518   Dali::NinePatchImage result;
47519
47520   if (!jarg1) {
47521     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
47522     return 0;
47523   }
47524   std::string arg1_str(jarg1);
47525   arg1 = &arg1_str;
47526   {
47527     try {
47528       result = Dali::NinePatchImage::New((std::string const &)*arg1);
47529     } catch (std::out_of_range& e) {
47530       {
47531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47532       };
47533     } catch (std::exception& e) {
47534       {
47535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47536       };
47537     } catch (Dali::DaliException e) {
47538       {
47539         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47540       };
47541     } catch (...) {
47542       {
47543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47544       };
47545     }
47546   }
47547
47548   jresult = new Dali::NinePatchImage((const Dali::NinePatchImage &)result);
47549
47550   //argout typemap for const std::string&
47551
47552   return jresult;
47553 }
47554
47555
47556 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_DownCast(void * jarg1) {
47557   void * jresult ;
47558   Dali::BaseHandle arg1 ;
47559   Dali::BaseHandle *argp1 ;
47560   Dali::NinePatchImage result;
47561
47562   argp1 = (Dali::BaseHandle *)jarg1;
47563   if (!argp1) {
47564     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
47565     return 0;
47566   }
47567   arg1 = *argp1;
47568   {
47569     try {
47570       result = Dali::NinePatchImage::DownCast(arg1);
47571     } catch (std::out_of_range& e) {
47572       {
47573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47574       };
47575     } catch (std::exception& e) {
47576       {
47577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47578       };
47579     } catch (Dali::DaliException e) {
47580       {
47581         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47582       };
47583     } catch (...) {
47584       {
47585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47586       };
47587     }
47588   }
47589
47590   jresult = new Dali::NinePatchImage((const Dali::NinePatchImage &)result);
47591   return jresult;
47592 }
47593
47594
47595 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_NinePatchImage(void * jarg1) {
47596   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47597
47598   arg1 = (Dali::NinePatchImage *)jarg1;
47599   {
47600     try {
47601       delete arg1;
47602     } catch (std::out_of_range& e) {
47603       {
47604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47605       };
47606     } catch (std::exception& e) {
47607       {
47608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47609       };
47610     } catch (Dali::DaliException e) {
47611       {
47612         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47613       };
47614     } catch (...) {
47615       {
47616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47617       };
47618     }
47619   }
47620
47621 }
47622
47623
47624 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NinePatchImage__SWIG_1(void * jarg1) {
47625   void * jresult ;
47626   Dali::NinePatchImage *arg1 = 0 ;
47627   Dali::NinePatchImage *result = 0 ;
47628
47629   arg1 = (Dali::NinePatchImage *)jarg1;
47630   if (!arg1) {
47631     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NinePatchImage const & type is null", 0);
47632     return 0;
47633   }
47634   {
47635     try {
47636       result = (Dali::NinePatchImage *)new Dali::NinePatchImage((Dali::NinePatchImage const &)*arg1);
47637     } catch (std::out_of_range& e) {
47638       {
47639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47640       };
47641     } catch (std::exception& e) {
47642       {
47643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47644       };
47645     } catch (Dali::DaliException e) {
47646       {
47647         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47648       };
47649     } catch (...) {
47650       {
47651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47652       };
47653     }
47654   }
47655
47656   jresult = (void *)result;
47657   return jresult;
47658 }
47659
47660
47661 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_Assign(void * jarg1, void * jarg2) {
47662   void * jresult ;
47663   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47664   Dali::NinePatchImage *arg2 = 0 ;
47665   Dali::NinePatchImage *result = 0 ;
47666
47667   arg1 = (Dali::NinePatchImage *)jarg1;
47668   arg2 = (Dali::NinePatchImage *)jarg2;
47669   if (!arg2) {
47670     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NinePatchImage const & type is null", 0);
47671     return 0;
47672   }
47673   {
47674     try {
47675       result = (Dali::NinePatchImage *) &(arg1)->operator =((Dali::NinePatchImage const &)*arg2);
47676     } catch (std::out_of_range& e) {
47677       {
47678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47679       };
47680     } catch (std::exception& e) {
47681       {
47682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47683       };
47684     } catch (Dali::DaliException e) {
47685       {
47686         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47687       };
47688     } catch (...) {
47689       {
47690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47691       };
47692     }
47693   }
47694
47695   jresult = (void *)result;
47696   return jresult;
47697 }
47698
47699
47700 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchBorders(void * jarg1) {
47701   void * jresult ;
47702   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47703   Dali::Vector4 result;
47704
47705   arg1 = (Dali::NinePatchImage *)jarg1;
47706   {
47707     try {
47708       result = (arg1)->GetStretchBorders();
47709     } catch (std::out_of_range& e) {
47710       {
47711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47712       };
47713     } catch (std::exception& e) {
47714       {
47715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47716       };
47717     } catch (Dali::DaliException e) {
47718       {
47719         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47720       };
47721     } catch (...) {
47722       {
47723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47724       };
47725     }
47726   }
47727
47728   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
47729   return jresult;
47730 }
47731
47732
47733 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchPixelsX(void * jarg1) {
47734   void * jresult ;
47735   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47736   Dali::NinePatchImage::StretchRanges *result = 0 ;
47737
47738   arg1 = (Dali::NinePatchImage *)jarg1;
47739   {
47740     try {
47741       result = (Dali::NinePatchImage::StretchRanges *) &(arg1)->GetStretchPixelsX();
47742     } catch (std::out_of_range& e) {
47743       {
47744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47745       };
47746     } catch (std::exception& e) {
47747       {
47748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47749       };
47750     } catch (Dali::DaliException e) {
47751       {
47752         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47753       };
47754     } catch (...) {
47755       {
47756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47757       };
47758     }
47759   }
47760
47761   jresult = (void *)result;
47762   return jresult;
47763 }
47764
47765
47766 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchPixelsY(void * jarg1) {
47767   void * jresult ;
47768   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47769   Dali::NinePatchImage::StretchRanges *result = 0 ;
47770
47771   arg1 = (Dali::NinePatchImage *)jarg1;
47772   {
47773     try {
47774       result = (Dali::NinePatchImage::StretchRanges *) &(arg1)->GetStretchPixelsY();
47775     } catch (std::out_of_range& e) {
47776       {
47777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47778       };
47779     } catch (std::exception& e) {
47780       {
47781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47782       };
47783     } catch (Dali::DaliException e) {
47784       {
47785         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47786       };
47787     } catch (...) {
47788       {
47789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47790       };
47791     }
47792   }
47793
47794   jresult = (void *)result;
47795   return jresult;
47796 }
47797
47798
47799 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetChildRectangle(void * jarg1) {
47800   void * jresult ;
47801   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47802   Dali::Rect< int > result;
47803
47804   arg1 = (Dali::NinePatchImage *)jarg1;
47805   {
47806     try {
47807       result = (arg1)->GetChildRectangle();
47808     } catch (std::out_of_range& e) {
47809       {
47810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47811       };
47812     } catch (std::exception& e) {
47813       {
47814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47815       };
47816     } catch (Dali::DaliException e) {
47817       {
47818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47819       };
47820     } catch (...) {
47821       {
47822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47823       };
47824     }
47825   }
47826
47827   jresult = new Dali::Rect< int >((const Dali::Rect< int > &)result);
47828   return jresult;
47829 }
47830
47831
47832 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_CreateCroppedBufferImage(void * jarg1) {
47833   void * jresult ;
47834   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47835   Dali::BufferImage result;
47836
47837   arg1 = (Dali::NinePatchImage *)jarg1;
47838   {
47839     try {
47840       result = (arg1)->CreateCroppedBufferImage();
47841     } catch (std::out_of_range& e) {
47842       {
47843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47844       };
47845     } catch (std::exception& e) {
47846       {
47847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47848       };
47849     } catch (Dali::DaliException e) {
47850       {
47851         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47852       };
47853     } catch (...) {
47854       {
47855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47856       };
47857     }
47858   }
47859
47860   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
47861   return jresult;
47862 }
47863
47864
47865 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NinePatchImage_IsNinePatchUrl(char * jarg1) {
47866   unsigned int jresult ;
47867   std::string *arg1 = 0 ;
47868   bool result;
47869
47870   if (!jarg1) {
47871     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
47872     return 0;
47873   }
47874   std::string arg1_str(jarg1);
47875   arg1 = &arg1_str;
47876   {
47877     try {
47878       result = (bool)Dali::NinePatchImage::IsNinePatchUrl((std::string const &)*arg1);
47879     } catch (std::out_of_range& e) {
47880       {
47881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47882       };
47883     } catch (std::exception& e) {
47884       {
47885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47886       };
47887     } catch (Dali::DaliException e) {
47888       {
47889         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47890       };
47891     } catch (...) {
47892       {
47893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47894       };
47895     }
47896   }
47897
47898   jresult = result;
47899
47900   //argout typemap for const std::string&
47901
47902   return jresult;
47903 }
47904
47905
47906 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TYPE_get() {
47907   int jresult ;
47908   int result;
47909
47910   result = (int)Dali::CameraActor::Property::TYPE;
47911   jresult = (int)result;
47912   return jresult;
47913 }
47914
47915
47916 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MODE_get() {
47917   int jresult ;
47918   int result;
47919
47920   result = (int)Dali::CameraActor::Property::PROJECTION_MODE;
47921   jresult = (int)result;
47922   return jresult;
47923 }
47924
47925
47926 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FIELD_OF_VIEW_get() {
47927   int jresult ;
47928   int result;
47929
47930   result = (int)Dali::CameraActor::Property::FIELD_OF_VIEW;
47931   jresult = (int)result;
47932   return jresult;
47933 }
47934
47935
47936 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_ASPECT_RATIO_get() {
47937   int jresult ;
47938   int result;
47939
47940   result = (int)Dali::CameraActor::Property::ASPECT_RATIO;
47941   jresult = (int)result;
47942   return jresult;
47943 }
47944
47945
47946 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_NEAR_PLANE_DISTANCE_get() {
47947   int jresult ;
47948   int result;
47949
47950   result = (int)Dali::CameraActor::Property::NEAR_PLANE_DISTANCE;
47951   jresult = (int)result;
47952   return jresult;
47953 }
47954
47955
47956 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FAR_PLANE_DISTANCE_get() {
47957   int jresult ;
47958   int result;
47959
47960   result = (int)Dali::CameraActor::Property::FAR_PLANE_DISTANCE;
47961   jresult = (int)result;
47962   return jresult;
47963 }
47964
47965
47966 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_LEFT_PLANE_DISTANCE_get() {
47967   int jresult ;
47968   int result;
47969
47970   result = (int)Dali::CameraActor::Property::LEFT_PLANE_DISTANCE;
47971   jresult = (int)result;
47972   return jresult;
47973 }
47974
47975
47976 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_RIGHT_PLANE_DISTANCE_get() {
47977   int jresult ;
47978   int result;
47979
47980   result = (int)Dali::CameraActor::Property::RIGHT_PLANE_DISTANCE;
47981   jresult = (int)result;
47982   return jresult;
47983 }
47984
47985
47986 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TOP_PLANE_DISTANCE_get() {
47987   int jresult ;
47988   int result;
47989
47990   result = (int)Dali::CameraActor::Property::TOP_PLANE_DISTANCE;
47991   jresult = (int)result;
47992   return jresult;
47993 }
47994
47995
47996 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_BOTTOM_PLANE_DISTANCE_get() {
47997   int jresult ;
47998   int result;
47999
48000   result = (int)Dali::CameraActor::Property::BOTTOM_PLANE_DISTANCE;
48001   jresult = (int)result;
48002   return jresult;
48003 }
48004
48005
48006 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TARGET_POSITION_get() {
48007   int jresult ;
48008   int result;
48009
48010   result = (int)Dali::CameraActor::Property::TARGET_POSITION;
48011   jresult = (int)result;
48012   return jresult;
48013 }
48014
48015
48016 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MATRIX_get() {
48017   int jresult ;
48018   int result;
48019
48020   result = (int)Dali::CameraActor::Property::PROJECTION_MATRIX;
48021   jresult = (int)result;
48022   return jresult;
48023 }
48024
48025
48026 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_VIEW_MATRIX_get() {
48027   int jresult ;
48028   int result;
48029
48030   result = (int)Dali::CameraActor::Property::VIEW_MATRIX;
48031   jresult = (int)result;
48032   return jresult;
48033 }
48034
48035
48036 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_INVERT_Y_AXIS_get() {
48037   int jresult ;
48038   int result;
48039
48040   result = (int)Dali::CameraActor::Property::INVERT_Y_AXIS;
48041   jresult = (int)result;
48042   return jresult;
48043 }
48044
48045
48046 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor_Property() {
48047   void * jresult ;
48048   Dali::CameraActor::Property *result = 0 ;
48049
48050   {
48051     try {
48052       result = (Dali::CameraActor::Property *)new Dali::CameraActor::Property();
48053     } catch (std::out_of_range& e) {
48054       {
48055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48056       };
48057     } catch (std::exception& e) {
48058       {
48059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48060       };
48061     } catch (Dali::DaliException e) {
48062       {
48063         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48064       };
48065     } catch (...) {
48066       {
48067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48068       };
48069     }
48070   }
48071
48072   jresult = (void *)result;
48073   return jresult;
48074 }
48075
48076
48077 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor_Property(void * jarg1) {
48078   Dali::CameraActor::Property *arg1 = (Dali::CameraActor::Property *) 0 ;
48079
48080   arg1 = (Dali::CameraActor::Property *)jarg1;
48081   {
48082     try {
48083       delete arg1;
48084     } catch (std::out_of_range& e) {
48085       {
48086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48087       };
48088     } catch (std::exception& e) {
48089       {
48090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48091       };
48092     } catch (Dali::DaliException e) {
48093       {
48094         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48095       };
48096     } catch (...) {
48097       {
48098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48099       };
48100     }
48101   }
48102
48103 }
48104
48105
48106 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_0() {
48107   void * jresult ;
48108   Dali::CameraActor *result = 0 ;
48109
48110   {
48111     try {
48112       result = (Dali::CameraActor *)new Dali::CameraActor();
48113     } catch (std::out_of_range& e) {
48114       {
48115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48116       };
48117     } catch (std::exception& e) {
48118       {
48119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48120       };
48121     } catch (Dali::DaliException e) {
48122       {
48123         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48124       };
48125     } catch (...) {
48126       {
48127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48128       };
48129     }
48130   }
48131
48132   jresult = (void *)result;
48133   return jresult;
48134 }
48135
48136
48137 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_0() {
48138   void * jresult ;
48139   Dali::CameraActor result;
48140
48141   {
48142     try {
48143       result = Dali::CameraActor::New();
48144     } catch (std::out_of_range& e) {
48145       {
48146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48147       };
48148     } catch (std::exception& e) {
48149       {
48150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48151       };
48152     } catch (Dali::DaliException e) {
48153       {
48154         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48155       };
48156     } catch (...) {
48157       {
48158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48159       };
48160     }
48161   }
48162
48163   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
48164   return jresult;
48165 }
48166
48167
48168 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_1(void * jarg1) {
48169   void * jresult ;
48170   Dali::Size *arg1 = 0 ;
48171   Dali::CameraActor result;
48172
48173   arg1 = (Dali::Size *)jarg1;
48174   if (!arg1) {
48175     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
48176     return 0;
48177   }
48178   {
48179     try {
48180       result = Dali::CameraActor::New((Dali::Vector2 const &)*arg1);
48181     } catch (std::out_of_range& e) {
48182       {
48183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48184       };
48185     } catch (std::exception& e) {
48186       {
48187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48188       };
48189     } catch (Dali::DaliException e) {
48190       {
48191         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48192       };
48193     } catch (...) {
48194       {
48195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48196       };
48197     }
48198   }
48199
48200   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
48201   return jresult;
48202 }
48203
48204
48205 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_DownCast(void * jarg1) {
48206   void * jresult ;
48207   Dali::BaseHandle arg1 ;
48208   Dali::BaseHandle *argp1 ;
48209   Dali::CameraActor result;
48210
48211   argp1 = (Dali::BaseHandle *)jarg1;
48212   if (!argp1) {
48213     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
48214     return 0;
48215   }
48216   arg1 = *argp1;
48217   {
48218     try {
48219       result = Dali::CameraActor::DownCast(arg1);
48220     } catch (std::out_of_range& e) {
48221       {
48222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48223       };
48224     } catch (std::exception& e) {
48225       {
48226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48227       };
48228     } catch (Dali::DaliException e) {
48229       {
48230         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48231       };
48232     } catch (...) {
48233       {
48234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48235       };
48236     }
48237   }
48238
48239   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
48240   return jresult;
48241 }
48242
48243
48244 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor(void * jarg1) {
48245   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48246
48247   arg1 = (Dali::CameraActor *)jarg1;
48248   {
48249     try {
48250       delete arg1;
48251     } catch (std::out_of_range& e) {
48252       {
48253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48254       };
48255     } catch (std::exception& e) {
48256       {
48257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48258       };
48259     } catch (Dali::DaliException e) {
48260       {
48261         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48262       };
48263     } catch (...) {
48264       {
48265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48266       };
48267     }
48268   }
48269
48270 }
48271
48272
48273 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_1(void * jarg1) {
48274   void * jresult ;
48275   Dali::CameraActor *arg1 = 0 ;
48276   Dali::CameraActor *result = 0 ;
48277
48278   arg1 = (Dali::CameraActor *)jarg1;
48279   if (!arg1) {
48280     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
48281     return 0;
48282   }
48283   {
48284     try {
48285       result = (Dali::CameraActor *)new Dali::CameraActor((Dali::CameraActor const &)*arg1);
48286     } catch (std::out_of_range& e) {
48287       {
48288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48289       };
48290     } catch (std::exception& e) {
48291       {
48292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48293       };
48294     } catch (Dali::DaliException e) {
48295       {
48296         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48297       };
48298     } catch (...) {
48299       {
48300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48301       };
48302     }
48303   }
48304
48305   jresult = (void *)result;
48306   return jresult;
48307 }
48308
48309
48310 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_Assign(void * jarg1, void * jarg2) {
48311   void * jresult ;
48312   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48313   Dali::CameraActor *arg2 = 0 ;
48314   Dali::CameraActor *result = 0 ;
48315
48316   arg1 = (Dali::CameraActor *)jarg1;
48317   arg2 = (Dali::CameraActor *)jarg2;
48318   if (!arg2) {
48319     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
48320     return 0;
48321   }
48322   {
48323     try {
48324       result = (Dali::CameraActor *) &(arg1)->operator =((Dali::CameraActor const &)*arg2);
48325     } catch (std::out_of_range& e) {
48326       {
48327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48328       };
48329     } catch (std::exception& e) {
48330       {
48331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48332       };
48333     } catch (Dali::DaliException e) {
48334       {
48335         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48336       };
48337     } catch (...) {
48338       {
48339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48340       };
48341     }
48342   }
48343
48344   jresult = (void *)result;
48345   return jresult;
48346 }
48347
48348
48349 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetType(void * jarg1, int jarg2) {
48350   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48351   Dali::Camera::Type arg2 ;
48352
48353   arg1 = (Dali::CameraActor *)jarg1;
48354   arg2 = (Dali::Camera::Type)jarg2;
48355   {
48356     try {
48357       (arg1)->SetType(arg2);
48358     } catch (std::out_of_range& e) {
48359       {
48360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48361       };
48362     } catch (std::exception& e) {
48363       {
48364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48365       };
48366     } catch (Dali::DaliException e) {
48367       {
48368         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48369       };
48370     } catch (...) {
48371       {
48372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48373       };
48374     }
48375   }
48376
48377 }
48378
48379
48380 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetType(void * jarg1) {
48381   int jresult ;
48382   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48383   Dali::Camera::Type result;
48384
48385   arg1 = (Dali::CameraActor *)jarg1;
48386   {
48387     try {
48388       result = (Dali::Camera::Type)((Dali::CameraActor const *)arg1)->GetType();
48389     } catch (std::out_of_range& e) {
48390       {
48391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48392       };
48393     } catch (std::exception& e) {
48394       {
48395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48396       };
48397     } catch (Dali::DaliException e) {
48398       {
48399         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48400       };
48401     } catch (...) {
48402       {
48403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48404       };
48405     }
48406   }
48407
48408   jresult = (int)result;
48409   return jresult;
48410 }
48411
48412
48413 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetProjectionMode(void * jarg1, int jarg2) {
48414   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48415   Dali::Camera::ProjectionMode arg2 ;
48416
48417   arg1 = (Dali::CameraActor *)jarg1;
48418   arg2 = (Dali::Camera::ProjectionMode)jarg2;
48419   {
48420     try {
48421       (arg1)->SetProjectionMode(arg2);
48422     } catch (std::out_of_range& e) {
48423       {
48424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48425       };
48426     } catch (std::exception& e) {
48427       {
48428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48429       };
48430     } catch (Dali::DaliException e) {
48431       {
48432         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48433       };
48434     } catch (...) {
48435       {
48436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48437       };
48438     }
48439   }
48440
48441 }
48442
48443
48444 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetProjectionMode(void * jarg1) {
48445   int jresult ;
48446   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48447   Dali::Camera::ProjectionMode result;
48448
48449   arg1 = (Dali::CameraActor *)jarg1;
48450   {
48451     try {
48452       result = (Dali::Camera::ProjectionMode)((Dali::CameraActor const *)arg1)->GetProjectionMode();
48453     } catch (std::out_of_range& e) {
48454       {
48455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48456       };
48457     } catch (std::exception& e) {
48458       {
48459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48460       };
48461     } catch (Dali::DaliException e) {
48462       {
48463         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48464       };
48465     } catch (...) {
48466       {
48467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48468       };
48469     }
48470   }
48471
48472   jresult = (int)result;
48473   return jresult;
48474 }
48475
48476
48477 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFieldOfView(void * jarg1, float jarg2) {
48478   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48479   float arg2 ;
48480
48481   arg1 = (Dali::CameraActor *)jarg1;
48482   arg2 = (float)jarg2;
48483   {
48484     try {
48485       (arg1)->SetFieldOfView(arg2);
48486     } catch (std::out_of_range& e) {
48487       {
48488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48489       };
48490     } catch (std::exception& e) {
48491       {
48492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48493       };
48494     } catch (Dali::DaliException e) {
48495       {
48496         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48497       };
48498     } catch (...) {
48499       {
48500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48501       };
48502     }
48503   }
48504
48505 }
48506
48507
48508 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFieldOfView(void * jarg1) {
48509   float jresult ;
48510   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48511   float result;
48512
48513   arg1 = (Dali::CameraActor *)jarg1;
48514   {
48515     try {
48516       result = (float)(arg1)->GetFieldOfView();
48517     } catch (std::out_of_range& e) {
48518       {
48519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48520       };
48521     } catch (std::exception& e) {
48522       {
48523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48524       };
48525     } catch (Dali::DaliException e) {
48526       {
48527         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48528       };
48529     } catch (...) {
48530       {
48531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48532       };
48533     }
48534   }
48535
48536   jresult = result;
48537   return jresult;
48538 }
48539
48540
48541 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetAspectRatio(void * jarg1, float jarg2) {
48542   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48543   float arg2 ;
48544
48545   arg1 = (Dali::CameraActor *)jarg1;
48546   arg2 = (float)jarg2;
48547   {
48548     try {
48549       (arg1)->SetAspectRatio(arg2);
48550     } catch (std::out_of_range& e) {
48551       {
48552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48553       };
48554     } catch (std::exception& e) {
48555       {
48556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48557       };
48558     } catch (Dali::DaliException e) {
48559       {
48560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48561       };
48562     } catch (...) {
48563       {
48564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48565       };
48566     }
48567   }
48568
48569 }
48570
48571
48572 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetAspectRatio(void * jarg1) {
48573   float jresult ;
48574   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48575   float result;
48576
48577   arg1 = (Dali::CameraActor *)jarg1;
48578   {
48579     try {
48580       result = (float)(arg1)->GetAspectRatio();
48581     } catch (std::out_of_range& e) {
48582       {
48583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48584       };
48585     } catch (std::exception& e) {
48586       {
48587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48588       };
48589     } catch (Dali::DaliException e) {
48590       {
48591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48592       };
48593     } catch (...) {
48594       {
48595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48596       };
48597     }
48598   }
48599
48600   jresult = result;
48601   return jresult;
48602 }
48603
48604
48605 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetNearClippingPlane(void * jarg1, float jarg2) {
48606   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48607   float arg2 ;
48608
48609   arg1 = (Dali::CameraActor *)jarg1;
48610   arg2 = (float)jarg2;
48611   {
48612     try {
48613       (arg1)->SetNearClippingPlane(arg2);
48614     } catch (std::out_of_range& e) {
48615       {
48616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48617       };
48618     } catch (std::exception& e) {
48619       {
48620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48621       };
48622     } catch (Dali::DaliException e) {
48623       {
48624         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48625       };
48626     } catch (...) {
48627       {
48628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48629       };
48630     }
48631   }
48632
48633 }
48634
48635
48636 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetNearClippingPlane(void * jarg1) {
48637   float jresult ;
48638   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48639   float result;
48640
48641   arg1 = (Dali::CameraActor *)jarg1;
48642   {
48643     try {
48644       result = (float)(arg1)->GetNearClippingPlane();
48645     } catch (std::out_of_range& e) {
48646       {
48647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48648       };
48649     } catch (std::exception& e) {
48650       {
48651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48652       };
48653     } catch (Dali::DaliException e) {
48654       {
48655         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48656       };
48657     } catch (...) {
48658       {
48659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48660       };
48661     }
48662   }
48663
48664   jresult = result;
48665   return jresult;
48666 }
48667
48668
48669 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFarClippingPlane(void * jarg1, float jarg2) {
48670   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48671   float arg2 ;
48672
48673   arg1 = (Dali::CameraActor *)jarg1;
48674   arg2 = (float)jarg2;
48675   {
48676     try {
48677       (arg1)->SetFarClippingPlane(arg2);
48678     } catch (std::out_of_range& e) {
48679       {
48680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48681       };
48682     } catch (std::exception& e) {
48683       {
48684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48685       };
48686     } catch (Dali::DaliException e) {
48687       {
48688         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48689       };
48690     } catch (...) {
48691       {
48692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48693       };
48694     }
48695   }
48696
48697 }
48698
48699
48700 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFarClippingPlane(void * jarg1) {
48701   float jresult ;
48702   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48703   float result;
48704
48705   arg1 = (Dali::CameraActor *)jarg1;
48706   {
48707     try {
48708       result = (float)(arg1)->GetFarClippingPlane();
48709     } catch (std::out_of_range& e) {
48710       {
48711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48712       };
48713     } catch (std::exception& e) {
48714       {
48715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48716       };
48717     } catch (Dali::DaliException e) {
48718       {
48719         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48720       };
48721     } catch (...) {
48722       {
48723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48724       };
48725     }
48726   }
48727
48728   jresult = result;
48729   return jresult;
48730 }
48731
48732
48733 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetTargetPosition(void * jarg1, void * jarg2) {
48734   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48735   Dali::Vector3 *arg2 = 0 ;
48736
48737   arg1 = (Dali::CameraActor *)jarg1;
48738   arg2 = (Dali::Vector3 *)jarg2;
48739   if (!arg2) {
48740     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
48741     return ;
48742   }
48743   {
48744     try {
48745       (arg1)->SetTargetPosition((Dali::Vector3 const &)*arg2);
48746     } catch (std::out_of_range& e) {
48747       {
48748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48749       };
48750     } catch (std::exception& e) {
48751       {
48752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48753       };
48754     } catch (Dali::DaliException e) {
48755       {
48756         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48757       };
48758     } catch (...) {
48759       {
48760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48761       };
48762     }
48763   }
48764
48765 }
48766
48767
48768 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_GetTargetPosition(void * jarg1) {
48769   void * jresult ;
48770   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48771   Dali::Vector3 result;
48772
48773   arg1 = (Dali::CameraActor *)jarg1;
48774   {
48775     try {
48776       result = ((Dali::CameraActor const *)arg1)->GetTargetPosition();
48777     } catch (std::out_of_range& e) {
48778       {
48779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48780       };
48781     } catch (std::exception& e) {
48782       {
48783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48784       };
48785     } catch (Dali::DaliException e) {
48786       {
48787         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48788       };
48789     } catch (...) {
48790       {
48791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48792       };
48793     }
48794   }
48795
48796   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
48797   return jresult;
48798 }
48799
48800
48801 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetInvertYAxis(void * jarg1, unsigned int jarg2) {
48802   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48803   bool arg2 ;
48804
48805   arg1 = (Dali::CameraActor *)jarg1;
48806   arg2 = jarg2 ? true : false;
48807   {
48808     try {
48809       (arg1)->SetInvertYAxis(arg2);
48810     } catch (std::out_of_range& e) {
48811       {
48812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48813       };
48814     } catch (std::exception& e) {
48815       {
48816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48817       };
48818     } catch (Dali::DaliException e) {
48819       {
48820         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48821       };
48822     } catch (...) {
48823       {
48824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48825       };
48826     }
48827   }
48828
48829 }
48830
48831
48832 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CameraActor_GetInvertYAxis(void * jarg1) {
48833   unsigned int jresult ;
48834   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48835   bool result;
48836
48837   arg1 = (Dali::CameraActor *)jarg1;
48838   {
48839     try {
48840       result = (bool)(arg1)->GetInvertYAxis();
48841     } catch (std::out_of_range& e) {
48842       {
48843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48844       };
48845     } catch (std::exception& e) {
48846       {
48847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48848       };
48849     } catch (Dali::DaliException e) {
48850       {
48851         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48852       };
48853     } catch (...) {
48854       {
48855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48856       };
48857     }
48858   }
48859
48860   jresult = result;
48861   return jresult;
48862 }
48863
48864
48865 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetPerspectiveProjection(void * jarg1, void * jarg2) {
48866   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48867   Dali::Size *arg2 = 0 ;
48868
48869   arg1 = (Dali::CameraActor *)jarg1;
48870   arg2 = (Dali::Size *)jarg2;
48871   if (!arg2) {
48872     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
48873     return ;
48874   }
48875   {
48876     try {
48877       (arg1)->SetPerspectiveProjection((Dali::Size const &)*arg2);
48878     } catch (std::out_of_range& e) {
48879       {
48880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48881       };
48882     } catch (std::exception& e) {
48883       {
48884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48885       };
48886     } catch (Dali::DaliException e) {
48887       {
48888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48889       };
48890     } catch (...) {
48891       {
48892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48893       };
48894     }
48895   }
48896
48897 }
48898
48899
48900 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_0(void * jarg1, void * jarg2) {
48901   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48902   Dali::Size *arg2 = 0 ;
48903
48904   arg1 = (Dali::CameraActor *)jarg1;
48905   arg2 = (Dali::Size *)jarg2;
48906   if (!arg2) {
48907     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
48908     return ;
48909   }
48910   {
48911     try {
48912       (arg1)->SetOrthographicProjection((Dali::Size const &)*arg2);
48913     } catch (std::out_of_range& e) {
48914       {
48915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48916       };
48917     } catch (std::exception& e) {
48918       {
48919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48920       };
48921     } catch (Dali::DaliException e) {
48922       {
48923         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48924       };
48925     } catch (...) {
48926       {
48927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48928       };
48929     }
48930   }
48931
48932 }
48933
48934
48935 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, float jarg6, float jarg7) {
48936   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48937   float arg2 ;
48938   float arg3 ;
48939   float arg4 ;
48940   float arg5 ;
48941   float arg6 ;
48942   float arg7 ;
48943
48944   arg1 = (Dali::CameraActor *)jarg1;
48945   arg2 = (float)jarg2;
48946   arg3 = (float)jarg3;
48947   arg4 = (float)jarg4;
48948   arg5 = (float)jarg5;
48949   arg6 = (float)jarg6;
48950   arg7 = (float)jarg7;
48951   {
48952     try {
48953       (arg1)->SetOrthographicProjection(arg2,arg3,arg4,arg5,arg6,arg7);
48954     } catch (std::out_of_range& e) {
48955       {
48956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48957       };
48958     } catch (std::exception& e) {
48959       {
48960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48961       };
48962     } catch (Dali::DaliException e) {
48963       {
48964         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48965       };
48966     } catch (...) {
48967       {
48968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48969       };
48970     }
48971   }
48972
48973 }
48974
48975
48976 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_0() {
48977   void * jresult ;
48978   std::pair< std::string,Dali::Property::Value > *result = 0 ;
48979
48980   {
48981     try {
48982       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >();
48983     } catch (std::out_of_range& e) {
48984       {
48985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48986       };
48987     } catch (std::exception& e) {
48988       {
48989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48990       };
48991     } catch (Dali::DaliException e) {
48992       {
48993         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48994       };
48995     } catch (...) {
48996       {
48997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48998       };
48999     }
49000   }
49001
49002   jresult = (void *)result;
49003   return jresult;
49004 }
49005
49006
49007 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_1(char * jarg1, void * jarg2) {
49008   void * jresult ;
49009   std::string arg1 ;
49010   Dali::Property::Value arg2 ;
49011   Dali::Property::Value *argp2 ;
49012   std::pair< std::string,Dali::Property::Value > *result = 0 ;
49013
49014   if (!jarg1) {
49015     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
49016     return 0;
49017   }
49018   (&arg1)->assign(jarg1);
49019   argp2 = (Dali::Property::Value *)jarg2;
49020   if (!argp2) {
49021     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
49022     return 0;
49023   }
49024   arg2 = *argp2;
49025   {
49026     try {
49027       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >(arg1,arg2);
49028     } catch (std::out_of_range& e) {
49029       {
49030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49031       };
49032     } catch (std::exception& e) {
49033       {
49034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49035       };
49036     } catch (Dali::DaliException e) {
49037       {
49038         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49039       };
49040     } catch (...) {
49041       {
49042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49043       };
49044     }
49045   }
49046
49047   jresult = (void *)result;
49048   return jresult;
49049 }
49050
49051
49052 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_2(void * jarg1) {
49053   void * jresult ;
49054   std::pair< std::string,Dali::Property::Value > *arg1 = 0 ;
49055   std::pair< std::string,Dali::Property::Value > *result = 0 ;
49056
49057   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49058   if (!arg1) {
49059     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< std::string,Dali::Property::Value > const & type is null", 0);
49060     return 0;
49061   }
49062   {
49063     try {
49064       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);
49065     } catch (std::out_of_range& e) {
49066       {
49067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49068       };
49069     } catch (std::exception& e) {
49070       {
49071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49072       };
49073     } catch (Dali::DaliException e) {
49074       {
49075         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49076       };
49077     } catch (...) {
49078       {
49079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49080       };
49081     }
49082   }
49083
49084   jresult = (void *)result;
49085   return jresult;
49086 }
49087
49088
49089 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_first_set(void * jarg1, char * jarg2) {
49090   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
49091   std::string *arg2 = 0 ;
49092
49093   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49094   if (!jarg2) {
49095     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
49096     return ;
49097   }
49098   std::string arg2_str(jarg2);
49099   arg2 = &arg2_str;
49100   if (arg1) (arg1)->first = *arg2;
49101
49102   //argout typemap for const std::string&
49103
49104 }
49105
49106
49107 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_StringValuePair_first_get(void * jarg1) {
49108   char * jresult ;
49109   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
49110   std::string *result = 0 ;
49111
49112   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49113   result = (std::string *) & ((arg1)->first);
49114   jresult = SWIG_csharp_string_callback(result->c_str());
49115   return jresult;
49116 }
49117
49118
49119 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_second_set(void * jarg1, void * jarg2) {
49120   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
49121   Dali::Property::Value *arg2 = (Dali::Property::Value *) 0 ;
49122
49123   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49124   arg2 = (Dali::Property::Value *)jarg2;
49125   if (arg1) (arg1)->second = *arg2;
49126 }
49127
49128
49129 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StringValuePair_second_get(void * jarg1) {
49130   void * jresult ;
49131   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
49132   Dali::Property::Value *result = 0 ;
49133
49134   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49135   result = (Dali::Property::Value *)& ((arg1)->second);
49136   jresult = (void *)result;
49137   return jresult;
49138 }
49139
49140
49141 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StringValuePair(void * jarg1) {
49142   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
49143
49144   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49145   {
49146     try {
49147       delete arg1;
49148     } catch (std::out_of_range& e) {
49149       {
49150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49151       };
49152     } catch (std::exception& e) {
49153       {
49154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49155       };
49156     } catch (Dali::DaliException e) {
49157       {
49158         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49159       };
49160     } catch (...) {
49161       {
49162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49163       };
49164     }
49165   }
49166
49167 }
49168
49169
49170 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Clear(void * jarg1) {
49171   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49172
49173   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49174   {
49175     try {
49176       (arg1)->clear();
49177     } catch (std::out_of_range& e) {
49178       {
49179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49180       };
49181     } catch (std::exception& e) {
49182       {
49183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49184       };
49185     } catch (Dali::DaliException e) {
49186       {
49187         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49188       };
49189     } catch (...) {
49190       {
49191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49192       };
49193     }
49194   }
49195
49196 }
49197
49198
49199 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Add(void * jarg1, void * jarg2) {
49200   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49201   Dali::TouchPoint *arg2 = 0 ;
49202
49203   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49204   arg2 = (Dali::TouchPoint *)jarg2;
49205   if (!arg2) {
49206     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
49207     return ;
49208   }
49209   {
49210     try {
49211       (arg1)->push_back((Dali::TouchPoint const &)*arg2);
49212     } catch (std::out_of_range& e) {
49213       {
49214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49215       };
49216     } catch (std::exception& e) {
49217       {
49218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49219       };
49220     } catch (Dali::DaliException e) {
49221       {
49222         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49223       };
49224     } catch (...) {
49225       {
49226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49227       };
49228     }
49229   }
49230
49231 }
49232
49233
49234 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_size(void * jarg1) {
49235   unsigned long jresult ;
49236   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49237   std::vector< Dali::TouchPoint >::size_type result;
49238
49239   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49240   {
49241     try {
49242       result = ((std::vector< Dali::TouchPoint > const *)arg1)->size();
49243     } catch (std::out_of_range& e) {
49244       {
49245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49246       };
49247     } catch (std::exception& e) {
49248       {
49249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49250       };
49251     } catch (Dali::DaliException e) {
49252       {
49253         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49254       };
49255     } catch (...) {
49256       {
49257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49258       };
49259     }
49260   }
49261
49262   jresult = (unsigned long)result;
49263   return jresult;
49264 }
49265
49266
49267 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_capacity(void * jarg1) {
49268   unsigned long jresult ;
49269   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49270   std::vector< Dali::TouchPoint >::size_type result;
49271
49272   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49273   {
49274     try {
49275       result = ((std::vector< Dali::TouchPoint > const *)arg1)->capacity();
49276     } catch (std::out_of_range& e) {
49277       {
49278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49279       };
49280     } catch (std::exception& e) {
49281       {
49282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49283       };
49284     } catch (Dali::DaliException e) {
49285       {
49286         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49287       };
49288     } catch (...) {
49289       {
49290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49291       };
49292     }
49293   }
49294
49295   jresult = (unsigned long)result;
49296   return jresult;
49297 }
49298
49299
49300 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_reserve(void * jarg1, unsigned long jarg2) {
49301   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49302   std::vector< Dali::TouchPoint >::size_type arg2 ;
49303
49304   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49305   arg2 = (std::vector< Dali::TouchPoint >::size_type)jarg2;
49306   {
49307     try {
49308       (arg1)->reserve(arg2);
49309     } catch (std::out_of_range& e) {
49310       {
49311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49312       };
49313     } catch (std::exception& e) {
49314       {
49315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49316       };
49317     } catch (Dali::DaliException e) {
49318       {
49319         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49320       };
49321     } catch (...) {
49322       {
49323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49324       };
49325     }
49326   }
49327
49328 }
49329
49330
49331 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_0() {
49332   void * jresult ;
49333   std::vector< Dali::TouchPoint > *result = 0 ;
49334
49335   {
49336     try {
49337       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >();
49338     } catch (std::out_of_range& e) {
49339       {
49340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49341       };
49342     } catch (std::exception& e) {
49343       {
49344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49345       };
49346     } catch (Dali::DaliException e) {
49347       {
49348         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49349       };
49350     } catch (...) {
49351       {
49352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49353       };
49354     }
49355   }
49356
49357   jresult = (void *)result;
49358   return jresult;
49359 }
49360
49361
49362 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_1(void * jarg1) {
49363   void * jresult ;
49364   std::vector< Dali::TouchPoint > *arg1 = 0 ;
49365   std::vector< Dali::TouchPoint > *result = 0 ;
49366
49367   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49368   if (!arg1) {
49369     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
49370     return 0;
49371   }
49372   {
49373     try {
49374       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >((std::vector< Dali::TouchPoint > const &)*arg1);
49375     } catch (std::out_of_range& e) {
49376       {
49377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49378       };
49379     } catch (std::exception& e) {
49380       {
49381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49382       };
49383     } catch (Dali::DaliException e) {
49384       {
49385         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49386       };
49387     } catch (...) {
49388       {
49389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49390       };
49391     }
49392   }
49393
49394   jresult = (void *)result;
49395   return jresult;
49396 }
49397
49398
49399 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_2(int jarg1) {
49400   void * jresult ;
49401   int arg1 ;
49402   std::vector< Dali::TouchPoint > *result = 0 ;
49403
49404   arg1 = (int)jarg1;
49405   {
49406     try {
49407       try {
49408         result = (std::vector< Dali::TouchPoint > *)new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(arg1);
49409       }
49410       catch(std::out_of_range &_e) {
49411         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49412         return 0;
49413       }
49414
49415     } catch (std::out_of_range& e) {
49416       {
49417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49418       };
49419     } catch (std::exception& e) {
49420       {
49421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49422       };
49423     } catch (Dali::DaliException e) {
49424       {
49425         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49426       };
49427     } catch (...) {
49428       {
49429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49430       };
49431     }
49432   }
49433
49434   jresult = (void *)result;
49435   return jresult;
49436 }
49437
49438
49439 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitemcopy(void * jarg1, int jarg2) {
49440   void * jresult ;
49441   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49442   int arg2 ;
49443   SwigValueWrapper< Dali::TouchPoint > result;
49444
49445   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49446   arg2 = (int)jarg2;
49447   {
49448     try {
49449       try {
49450         result = std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(arg1,arg2);
49451       }
49452       catch(std::out_of_range &_e) {
49453         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49454         return 0;
49455       }
49456
49457     } catch (std::out_of_range& e) {
49458       {
49459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49460       };
49461     } catch (std::exception& e) {
49462       {
49463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49464       };
49465     } catch (Dali::DaliException e) {
49466       {
49467         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49468       };
49469     } catch (...) {
49470       {
49471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49472       };
49473     }
49474   }
49475
49476   jresult = new Dali::TouchPoint((const Dali::TouchPoint &)result);
49477   return jresult;
49478 }
49479
49480
49481 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitem(void * jarg1, int jarg2) {
49482   void * jresult ;
49483   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49484   int arg2 ;
49485   Dali::TouchPoint *result = 0 ;
49486
49487   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49488   arg2 = (int)jarg2;
49489   {
49490     try {
49491       try {
49492         result = (Dali::TouchPoint *) &std_vector_Sl_Dali_TouchPoint_Sg__getitem(arg1,arg2);
49493       }
49494       catch(std::out_of_range &_e) {
49495         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49496         return 0;
49497       }
49498
49499     } catch (std::out_of_range& e) {
49500       {
49501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49502       };
49503     } catch (std::exception& e) {
49504       {
49505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49506       };
49507     } catch (Dali::DaliException e) {
49508       {
49509         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49510       };
49511     } catch (...) {
49512       {
49513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49514       };
49515     }
49516   }
49517
49518   jresult = (void *)result;
49519   return jresult;
49520 }
49521
49522
49523 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
49524   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49525   int arg2 ;
49526   Dali::TouchPoint *arg3 = 0 ;
49527
49528   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49529   arg2 = (int)jarg2;
49530   arg3 = (Dali::TouchPoint *)jarg3;
49531   if (!arg3) {
49532     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
49533     return ;
49534   }
49535   {
49536     try {
49537       try {
49538         std_vector_Sl_Dali_TouchPoint_Sg__setitem(arg1,arg2,(Dali::TouchPoint const &)*arg3);
49539       }
49540       catch(std::out_of_range &_e) {
49541         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49542         return ;
49543       }
49544
49545     } catch (std::out_of_range& e) {
49546       {
49547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49548       };
49549     } catch (std::exception& e) {
49550       {
49551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49552       };
49553     } catch (Dali::DaliException e) {
49554       {
49555         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49556       };
49557     } catch (...) {
49558       {
49559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49560       };
49561     }
49562   }
49563
49564 }
49565
49566
49567 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_AddRange(void * jarg1, void * jarg2) {
49568   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49569   std::vector< Dali::TouchPoint > *arg2 = 0 ;
49570
49571   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49572   arg2 = (std::vector< Dali::TouchPoint > *)jarg2;
49573   if (!arg2) {
49574     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
49575     return ;
49576   }
49577   {
49578     try {
49579       std_vector_Sl_Dali_TouchPoint_Sg__AddRange(arg1,(std::vector< Dali::TouchPoint > const &)*arg2);
49580     } catch (std::out_of_range& e) {
49581       {
49582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49583       };
49584     } catch (std::exception& e) {
49585       {
49586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49587       };
49588     } catch (Dali::DaliException e) {
49589       {
49590         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49591       };
49592     } catch (...) {
49593       {
49594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49595       };
49596     }
49597   }
49598
49599 }
49600
49601
49602 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
49603   void * jresult ;
49604   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49605   int arg2 ;
49606   int arg3 ;
49607   std::vector< Dali::TouchPoint > *result = 0 ;
49608
49609   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49610   arg2 = (int)jarg2;
49611   arg3 = (int)jarg3;
49612   {
49613     try {
49614       try {
49615         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__GetRange(arg1,arg2,arg3);
49616       }
49617       catch(std::out_of_range &_e) {
49618         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49619         return 0;
49620       }
49621       catch(std::invalid_argument &_e) {
49622         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
49623         return 0;
49624       }
49625
49626     } catch (std::out_of_range& e) {
49627       {
49628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49629       };
49630     } catch (std::exception& e) {
49631       {
49632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49633       };
49634     } catch (Dali::DaliException e) {
49635       {
49636         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49637       };
49638     } catch (...) {
49639       {
49640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49641       };
49642     }
49643   }
49644
49645   jresult = (void *)result;
49646   return jresult;
49647 }
49648
49649
49650 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
49651   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49652   int arg2 ;
49653   Dali::TouchPoint *arg3 = 0 ;
49654
49655   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49656   arg2 = (int)jarg2;
49657   arg3 = (Dali::TouchPoint *)jarg3;
49658   if (!arg3) {
49659     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
49660     return ;
49661   }
49662   {
49663     try {
49664       try {
49665         std_vector_Sl_Dali_TouchPoint_Sg__Insert(arg1,arg2,(Dali::TouchPoint const &)*arg3);
49666       }
49667       catch(std::out_of_range &_e) {
49668         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49669         return ;
49670       }
49671
49672     } catch (std::out_of_range& e) {
49673       {
49674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49675       };
49676     } catch (std::exception& e) {
49677       {
49678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49679       };
49680     } catch (Dali::DaliException e) {
49681       {
49682         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49683       };
49684     } catch (...) {
49685       {
49686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49687       };
49688     }
49689   }
49690
49691 }
49692
49693
49694 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
49695   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49696   int arg2 ;
49697   std::vector< Dali::TouchPoint > *arg3 = 0 ;
49698
49699   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49700   arg2 = (int)jarg2;
49701   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
49702   if (!arg3) {
49703     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
49704     return ;
49705   }
49706   {
49707     try {
49708       try {
49709         std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
49710       }
49711       catch(std::out_of_range &_e) {
49712         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49713         return ;
49714       }
49715
49716     } catch (std::out_of_range& e) {
49717       {
49718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49719       };
49720     } catch (std::exception& e) {
49721       {
49722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49723       };
49724     } catch (Dali::DaliException e) {
49725       {
49726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49727       };
49728     } catch (...) {
49729       {
49730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49731       };
49732     }
49733   }
49734
49735 }
49736
49737
49738 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveAt(void * jarg1, int jarg2) {
49739   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49740   int arg2 ;
49741
49742   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49743   arg2 = (int)jarg2;
49744   {
49745     try {
49746       try {
49747         std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(arg1,arg2);
49748       }
49749       catch(std::out_of_range &_e) {
49750         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49751         return ;
49752       }
49753
49754     } catch (std::out_of_range& e) {
49755       {
49756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49757       };
49758     } catch (std::exception& e) {
49759       {
49760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49761       };
49762     } catch (Dali::DaliException e) {
49763       {
49764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49765       };
49766     } catch (...) {
49767       {
49768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49769       };
49770     }
49771   }
49772
49773 }
49774
49775
49776 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
49777   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49778   int arg2 ;
49779   int arg3 ;
49780
49781   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49782   arg2 = (int)jarg2;
49783   arg3 = (int)jarg3;
49784   {
49785     try {
49786       try {
49787         std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(arg1,arg2,arg3);
49788       }
49789       catch(std::out_of_range &_e) {
49790         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49791         return ;
49792       }
49793       catch(std::invalid_argument &_e) {
49794         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
49795         return ;
49796       }
49797
49798     } catch (std::out_of_range& e) {
49799       {
49800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49801       };
49802     } catch (std::exception& e) {
49803       {
49804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49805       };
49806     } catch (Dali::DaliException e) {
49807       {
49808         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49809       };
49810     } catch (...) {
49811       {
49812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49813       };
49814     }
49815   }
49816
49817 }
49818
49819
49820 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_Repeat(void * jarg1, int jarg2) {
49821   void * jresult ;
49822   Dali::TouchPoint *arg1 = 0 ;
49823   int arg2 ;
49824   std::vector< Dali::TouchPoint > *result = 0 ;
49825
49826   arg1 = (Dali::TouchPoint *)jarg1;
49827   if (!arg1) {
49828     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
49829     return 0;
49830   }
49831   arg2 = (int)jarg2;
49832   {
49833     try {
49834       try {
49835         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__Repeat((Dali::TouchPoint const &)*arg1,arg2);
49836       }
49837       catch(std::out_of_range &_e) {
49838         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49839         return 0;
49840       }
49841
49842     } catch (std::out_of_range& e) {
49843       {
49844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49845       };
49846     } catch (std::exception& e) {
49847       {
49848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49849       };
49850     } catch (Dali::DaliException e) {
49851       {
49852         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49853       };
49854     } catch (...) {
49855       {
49856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49857       };
49858     }
49859   }
49860
49861   jresult = (void *)result;
49862   return jresult;
49863 }
49864
49865
49866 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_0(void * jarg1) {
49867   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49868
49869   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49870   {
49871     try {
49872       std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(arg1);
49873     } catch (std::out_of_range& e) {
49874       {
49875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49876       };
49877     } catch (std::exception& e) {
49878       {
49879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49880       };
49881     } catch (Dali::DaliException e) {
49882       {
49883         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49884       };
49885     } catch (...) {
49886       {
49887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49888       };
49889     }
49890   }
49891
49892 }
49893
49894
49895 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
49896   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49897   int arg2 ;
49898   int arg3 ;
49899
49900   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49901   arg2 = (int)jarg2;
49902   arg3 = (int)jarg3;
49903   {
49904     try {
49905       try {
49906         std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
49907       }
49908       catch(std::out_of_range &_e) {
49909         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49910         return ;
49911       }
49912       catch(std::invalid_argument &_e) {
49913         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
49914         return ;
49915       }
49916
49917     } catch (std::out_of_range& e) {
49918       {
49919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49920       };
49921     } catch (std::exception& e) {
49922       {
49923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49924       };
49925     } catch (Dali::DaliException e) {
49926       {
49927         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49928       };
49929     } catch (...) {
49930       {
49931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49932       };
49933     }
49934   }
49935
49936 }
49937
49938
49939 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
49940   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49941   int arg2 ;
49942   std::vector< Dali::TouchPoint > *arg3 = 0 ;
49943
49944   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49945   arg2 = (int)jarg2;
49946   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
49947   if (!arg3) {
49948     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
49949     return ;
49950   }
49951   {
49952     try {
49953       try {
49954         std_vector_Sl_Dali_TouchPoint_Sg__SetRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
49955       }
49956       catch(std::out_of_range &_e) {
49957         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49958         return ;
49959       }
49960
49961     } catch (std::out_of_range& e) {
49962       {
49963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49964       };
49965     } catch (std::exception& e) {
49966       {
49967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49968       };
49969     } catch (Dali::DaliException e) {
49970       {
49971         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49972       };
49973     } catch (...) {
49974       {
49975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49976       };
49977     }
49978   }
49979
49980 }
49981
49982
49983 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPointContainer(void * jarg1) {
49984   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49985
49986   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49987   {
49988     try {
49989       delete arg1;
49990     } catch (std::out_of_range& e) {
49991       {
49992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49993       };
49994     } catch (std::exception& e) {
49995       {
49996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49997       };
49998     } catch (Dali::DaliException e) {
49999       {
50000         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50001       };
50002     } catch (...) {
50003       {
50004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50005       };
50006     }
50007   }
50008
50009 }
50010
50011
50012 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_0() {
50013   void * jresult ;
50014   Dali::Rect< int > *result = 0 ;
50015
50016   {
50017     try {
50018       result = (Dali::Rect< int > *)new Dali::Rect< int >();
50019     } catch (std::out_of_range& e) {
50020       {
50021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50022       };
50023     } catch (std::exception& e) {
50024       {
50025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50026       };
50027     } catch (Dali::DaliException e) {
50028       {
50029         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50030       };
50031     } catch (...) {
50032       {
50033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50034       };
50035     }
50036   }
50037
50038   jresult = (void *)result;
50039   return jresult;
50040 }
50041
50042
50043 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_1(int jarg1, int jarg2, int jarg3, int jarg4) {
50044   void * jresult ;
50045   int arg1 ;
50046   int arg2 ;
50047   int arg3 ;
50048   int arg4 ;
50049   Dali::Rect< int > *result = 0 ;
50050
50051   arg1 = (int)jarg1;
50052   arg2 = (int)jarg2;
50053   arg3 = (int)jarg3;
50054   arg4 = (int)jarg4;
50055   {
50056     try {
50057       result = (Dali::Rect< int > *)new Dali::Rect< int >(arg1,arg2,arg3,arg4);
50058     } catch (std::out_of_range& e) {
50059       {
50060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50061       };
50062     } catch (std::exception& e) {
50063       {
50064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50065       };
50066     } catch (Dali::DaliException e) {
50067       {
50068         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50069       };
50070     } catch (...) {
50071       {
50072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50073       };
50074     }
50075   }
50076
50077   jresult = (void *)result;
50078   return jresult;
50079 }
50080
50081
50082 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_2(void * jarg1) {
50083   void * jresult ;
50084   Dali::Rect< int > *arg1 = 0 ;
50085   Dali::Rect< int > *result = 0 ;
50086
50087   arg1 = (Dali::Rect< int > *)jarg1;
50088   if (!arg1) {
50089     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
50090     return 0;
50091   }
50092   {
50093     try {
50094       result = (Dali::Rect< int > *)new Dali::Rect< int >((Dali::Rect< int > const &)*arg1);
50095     } catch (std::out_of_range& e) {
50096       {
50097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50098       };
50099     } catch (std::exception& e) {
50100       {
50101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50102       };
50103     } catch (Dali::DaliException e) {
50104       {
50105         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50106       };
50107     } catch (...) {
50108       {
50109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50110       };
50111     }
50112   }
50113
50114   jresult = (void *)result;
50115   return jresult;
50116 }
50117
50118
50119 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rectangle_Assign(void * jarg1, void * jarg2) {
50120   void * jresult ;
50121   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50122   Dali::Rect< int > *arg2 = 0 ;
50123   Dali::Rect< int > *result = 0 ;
50124
50125   arg1 = (Dali::Rect< int > *)jarg1;
50126   arg2 = (Dali::Rect< int > *)jarg2;
50127   if (!arg2) {
50128     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
50129     return 0;
50130   }
50131   {
50132     try {
50133       result = (Dali::Rect< int > *) &(arg1)->operator =((Dali::Rect< int > const &)*arg2);
50134     } catch (std::out_of_range& e) {
50135       {
50136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50137       };
50138     } catch (std::exception& e) {
50139       {
50140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50141       };
50142     } catch (Dali::DaliException e) {
50143       {
50144         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50145       };
50146     } catch (...) {
50147       {
50148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50149       };
50150     }
50151   }
50152
50153   jresult = (void *)result;
50154   return jresult;
50155 }
50156
50157
50158 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_Set(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
50159   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50160   int arg2 ;
50161   int arg3 ;
50162   int arg4 ;
50163   int arg5 ;
50164
50165   arg1 = (Dali::Rect< int > *)jarg1;
50166   arg2 = (int)jarg2;
50167   arg3 = (int)jarg3;
50168   arg4 = (int)jarg4;
50169   arg5 = (int)jarg5;
50170   {
50171     try {
50172       (arg1)->Set(arg2,arg3,arg4,arg5);
50173     } catch (std::out_of_range& e) {
50174       {
50175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50176       };
50177     } catch (std::exception& e) {
50178       {
50179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50180       };
50181     } catch (Dali::DaliException e) {
50182       {
50183         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50184       };
50185     } catch (...) {
50186       {
50187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50188       };
50189     }
50190   }
50191
50192 }
50193
50194
50195 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_IsEmpty(void * jarg1) {
50196   unsigned int jresult ;
50197   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50198   bool result;
50199
50200   arg1 = (Dali::Rect< int > *)jarg1;
50201   {
50202     try {
50203       result = (bool)((Dali::Rect< int > const *)arg1)->IsEmpty();
50204     } catch (std::out_of_range& e) {
50205       {
50206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50207       };
50208     } catch (std::exception& e) {
50209       {
50210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50211       };
50212     } catch (Dali::DaliException e) {
50213       {
50214         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50215       };
50216     } catch (...) {
50217       {
50218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50219       };
50220     }
50221   }
50222
50223   jresult = result;
50224   return jresult;
50225 }
50226
50227
50228 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Left(void * jarg1) {
50229   int jresult ;
50230   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50231   int result;
50232
50233   arg1 = (Dali::Rect< int > *)jarg1;
50234   {
50235     try {
50236       result = (int)((Dali::Rect< int > const *)arg1)->Left();
50237     } catch (std::out_of_range& e) {
50238       {
50239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50240       };
50241     } catch (std::exception& e) {
50242       {
50243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50244       };
50245     } catch (Dali::DaliException e) {
50246       {
50247         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50248       };
50249     } catch (...) {
50250       {
50251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50252       };
50253     }
50254   }
50255
50256   jresult = result;
50257   return jresult;
50258 }
50259
50260
50261 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Right(void * jarg1) {
50262   int jresult ;
50263   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50264   int result;
50265
50266   arg1 = (Dali::Rect< int > *)jarg1;
50267   {
50268     try {
50269       result = (int)((Dali::Rect< int > const *)arg1)->Right();
50270     } catch (std::out_of_range& e) {
50271       {
50272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50273       };
50274     } catch (std::exception& e) {
50275       {
50276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50277       };
50278     } catch (Dali::DaliException e) {
50279       {
50280         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50281       };
50282     } catch (...) {
50283       {
50284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50285       };
50286     }
50287   }
50288
50289   jresult = result;
50290   return jresult;
50291 }
50292
50293
50294 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Top(void * jarg1) {
50295   int jresult ;
50296   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50297   int result;
50298
50299   arg1 = (Dali::Rect< int > *)jarg1;
50300   {
50301     try {
50302       result = (int)((Dali::Rect< int > const *)arg1)->Top();
50303     } catch (std::out_of_range& e) {
50304       {
50305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50306       };
50307     } catch (std::exception& e) {
50308       {
50309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50310       };
50311     } catch (Dali::DaliException e) {
50312       {
50313         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50314       };
50315     } catch (...) {
50316       {
50317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50318       };
50319     }
50320   }
50321
50322   jresult = result;
50323   return jresult;
50324 }
50325
50326
50327 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Bottom(void * jarg1) {
50328   int jresult ;
50329   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50330   int result;
50331
50332   arg1 = (Dali::Rect< int > *)jarg1;
50333   {
50334     try {
50335       result = (int)((Dali::Rect< int > const *)arg1)->Bottom();
50336     } catch (std::out_of_range& e) {
50337       {
50338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50339       };
50340     } catch (std::exception& e) {
50341       {
50342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50343       };
50344     } catch (Dali::DaliException e) {
50345       {
50346         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50347       };
50348     } catch (...) {
50349       {
50350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50351       };
50352     }
50353   }
50354
50355   jresult = result;
50356   return jresult;
50357 }
50358
50359
50360 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Area(void * jarg1) {
50361   int jresult ;
50362   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50363   int result;
50364
50365   arg1 = (Dali::Rect< int > *)jarg1;
50366   {
50367     try {
50368       result = (int)((Dali::Rect< int > const *)arg1)->Area();
50369     } catch (std::out_of_range& e) {
50370       {
50371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50372       };
50373     } catch (std::exception& e) {
50374       {
50375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50376       };
50377     } catch (Dali::DaliException e) {
50378       {
50379         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50380       };
50381     } catch (...) {
50382       {
50383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50384       };
50385     }
50386   }
50387
50388   jresult = result;
50389   return jresult;
50390 }
50391
50392
50393 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Intersects(void * jarg1, void * jarg2) {
50394   unsigned int jresult ;
50395   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50396   Dali::Rect< int > *arg2 = 0 ;
50397   bool result;
50398
50399   arg1 = (Dali::Rect< int > *)jarg1;
50400   arg2 = (Dali::Rect< int > *)jarg2;
50401   if (!arg2) {
50402     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
50403     return 0;
50404   }
50405   {
50406     try {
50407       result = (bool)((Dali::Rect< int > const *)arg1)->Intersects((Dali::Rect< int > const &)*arg2);
50408     } catch (std::out_of_range& e) {
50409       {
50410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50411       };
50412     } catch (std::exception& e) {
50413       {
50414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50415       };
50416     } catch (Dali::DaliException e) {
50417       {
50418         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50419       };
50420     } catch (...) {
50421       {
50422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50423       };
50424     }
50425   }
50426
50427   jresult = result;
50428   return jresult;
50429 }
50430
50431
50432 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Contains(void * jarg1, void * jarg2) {
50433   unsigned int jresult ;
50434   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50435   Dali::Rect< int > *arg2 = 0 ;
50436   bool result;
50437
50438   arg1 = (Dali::Rect< int > *)jarg1;
50439   arg2 = (Dali::Rect< int > *)jarg2;
50440   if (!arg2) {
50441     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
50442     return 0;
50443   }
50444   {
50445     try {
50446       result = (bool)((Dali::Rect< int > const *)arg1)->Contains((Dali::Rect< int > const &)*arg2);
50447     } catch (std::out_of_range& e) {
50448       {
50449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50450       };
50451     } catch (std::exception& e) {
50452       {
50453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50454       };
50455     } catch (Dali::DaliException e) {
50456       {
50457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50458       };
50459     } catch (...) {
50460       {
50461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50462       };
50463     }
50464   }
50465
50466   jresult = result;
50467   return jresult;
50468 }
50469
50470
50471 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_x_set(void * jarg1, int jarg2) {
50472   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50473   int arg2 ;
50474
50475   arg1 = (Dali::Rect< int > *)jarg1;
50476   arg2 = (int)jarg2;
50477   if (arg1) (arg1)->x = arg2;
50478 }
50479
50480
50481 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_x_get(void * jarg1) {
50482   int jresult ;
50483   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50484   int result;
50485
50486   arg1 = (Dali::Rect< int > *)jarg1;
50487   result = (int) ((arg1)->x);
50488   jresult = result;
50489   return jresult;
50490 }
50491
50492
50493 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_left_set(void * jarg1, int jarg2) {
50494   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50495   int arg2 ;
50496
50497   arg1 = (Dali::Rect< int > *)jarg1;
50498   arg2 = (int)jarg2;
50499   if (arg1) (arg1)->left = arg2;
50500 }
50501
50502
50503 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_left_get(void * jarg1) {
50504   int jresult ;
50505   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50506   int result;
50507
50508   arg1 = (Dali::Rect< int > *)jarg1;
50509   result = (int) ((arg1)->left);
50510   jresult = result;
50511   return jresult;
50512 }
50513
50514
50515 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_y_set(void * jarg1, int jarg2) {
50516   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50517   int arg2 ;
50518
50519   arg1 = (Dali::Rect< int > *)jarg1;
50520   arg2 = (int)jarg2;
50521   if (arg1) (arg1)->y = arg2;
50522 }
50523
50524
50525 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_y_get(void * jarg1) {
50526   int jresult ;
50527   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50528   int result;
50529
50530   arg1 = (Dali::Rect< int > *)jarg1;
50531   result = (int) ((arg1)->y);
50532   jresult = result;
50533   return jresult;
50534 }
50535
50536
50537 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_right_set(void * jarg1, int jarg2) {
50538   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50539   int arg2 ;
50540
50541   arg1 = (Dali::Rect< int > *)jarg1;
50542   arg2 = (int)jarg2;
50543   if (arg1) (arg1)->right = arg2;
50544 }
50545
50546
50547 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_right_get(void * jarg1) {
50548   int jresult ;
50549   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50550   int result;
50551
50552   arg1 = (Dali::Rect< int > *)jarg1;
50553   result = (int) ((arg1)->right);
50554   jresult = result;
50555   return jresult;
50556 }
50557
50558
50559 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_width_set(void * jarg1, int jarg2) {
50560   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50561   int arg2 ;
50562
50563   arg1 = (Dali::Rect< int > *)jarg1;
50564   arg2 = (int)jarg2;
50565   if (arg1) (arg1)->width = arg2;
50566 }
50567
50568
50569 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_width_get(void * jarg1) {
50570   int jresult ;
50571   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50572   int result;
50573
50574   arg1 = (Dali::Rect< int > *)jarg1;
50575   result = (int) ((arg1)->width);
50576   jresult = result;
50577   return jresult;
50578 }
50579
50580
50581 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_bottom_set(void * jarg1, int jarg2) {
50582   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50583   int arg2 ;
50584
50585   arg1 = (Dali::Rect< int > *)jarg1;
50586   arg2 = (int)jarg2;
50587   if (arg1) (arg1)->bottom = arg2;
50588 }
50589
50590
50591 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_bottom_get(void * jarg1) {
50592   int jresult ;
50593   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50594   int result;
50595
50596   arg1 = (Dali::Rect< int > *)jarg1;
50597   result = (int) ((arg1)->bottom);
50598   jresult = result;
50599   return jresult;
50600 }
50601
50602
50603 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_height_set(void * jarg1, int jarg2) {
50604   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50605   int arg2 ;
50606
50607   arg1 = (Dali::Rect< int > *)jarg1;
50608   arg2 = (int)jarg2;
50609   if (arg1) (arg1)->height = arg2;
50610 }
50611
50612
50613 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_height_get(void * jarg1) {
50614   int jresult ;
50615   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50616   int result;
50617
50618   arg1 = (Dali::Rect< int > *)jarg1;
50619   result = (int) ((arg1)->height);
50620   jresult = result;
50621   return jresult;
50622 }
50623
50624
50625 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_top_set(void * jarg1, int jarg2) {
50626   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50627   int arg2 ;
50628
50629   arg1 = (Dali::Rect< int > *)jarg1;
50630   arg2 = (int)jarg2;
50631   if (arg1) (arg1)->top = arg2;
50632 }
50633
50634
50635 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_top_get(void * jarg1) {
50636   int jresult ;
50637   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50638   int result;
50639
50640   arg1 = (Dali::Rect< int > *)jarg1;
50641   result = (int) ((arg1)->top);
50642   jresult = result;
50643   return jresult;
50644 }
50645
50646
50647 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rectangle(void * jarg1) {
50648   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50649
50650   arg1 = (Dali::Rect< int > *)jarg1;
50651   {
50652     try {
50653       delete arg1;
50654     } catch (std::out_of_range& e) {
50655       {
50656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50657       };
50658     } catch (std::exception& e) {
50659       {
50660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50661       };
50662     } catch (Dali::DaliException e) {
50663       {
50664         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50665       };
50666     } catch (...) {
50667       {
50668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50669       };
50670     }
50671   }
50672
50673 }
50674
50675
50676 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_0() {
50677   void * jresult ;
50678   Dali::Rect< float > *result = 0 ;
50679
50680   {
50681     try {
50682       result = (Dali::Rect< float > *)new Dali::Rect< float >();
50683     } catch (std::out_of_range& e) {
50684       {
50685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50686       };
50687     } catch (std::exception& e) {
50688       {
50689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50690       };
50691     } catch (Dali::DaliException e) {
50692       {
50693         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50694       };
50695     } catch (...) {
50696       {
50697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50698       };
50699     }
50700   }
50701
50702   jresult = (void *)result;
50703   return jresult;
50704 }
50705
50706
50707 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
50708   void * jresult ;
50709   float arg1 ;
50710   float arg2 ;
50711   float arg3 ;
50712   float arg4 ;
50713   Dali::Rect< float > *result = 0 ;
50714
50715   arg1 = (float)jarg1;
50716   arg2 = (float)jarg2;
50717   arg3 = (float)jarg4;
50718   arg4 = (float)jarg3;
50719   {
50720     try {
50721       result = (Dali::Rect< float > *)new Dali::Rect< float >(arg1,arg2,arg3,arg4);
50722     } catch (std::out_of_range& e) {
50723       {
50724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50725       };
50726     } catch (std::exception& e) {
50727       {
50728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50729       };
50730     } catch (Dali::DaliException e) {
50731       {
50732         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50733       };
50734     } catch (...) {
50735       {
50736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50737       };
50738     }
50739   }
50740
50741   jresult = (void *)result;
50742   return jresult;
50743 }
50744
50745
50746 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_2(void * jarg1) {
50747   void * jresult ;
50748   Dali::Rect< float > *arg1 = 0 ;
50749   Dali::Rect< float > *result = 0 ;
50750
50751   arg1 = (Dali::Rect< float > *)jarg1;
50752   if (!arg1) {
50753     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
50754     return 0;
50755   }
50756   {
50757     try {
50758       result = (Dali::Rect< float > *)new Dali::Rect< float >((Dali::Rect< float > const &)*arg1);
50759     } catch (std::out_of_range& e) {
50760       {
50761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50762       };
50763     } catch (std::exception& e) {
50764       {
50765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50766       };
50767     } catch (Dali::DaliException e) {
50768       {
50769         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50770       };
50771     } catch (...) {
50772       {
50773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50774       };
50775     }
50776   }
50777
50778   jresult = (void *)result;
50779   return jresult;
50780 }
50781
50782
50783 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PaddingType_Assign(void * jarg1, void * jarg2) {
50784   void * jresult ;
50785   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50786   Dali::Rect< float > *arg2 = 0 ;
50787   Dali::Rect< float > *result = 0 ;
50788
50789   arg1 = (Dali::Rect< float > *)jarg1;
50790   arg2 = (Dali::Rect< float > *)jarg2;
50791   if (!arg2) {
50792     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
50793     return 0;
50794   }
50795   {
50796     try {
50797       result = (Dali::Rect< float > *) &(arg1)->operator =((Dali::Rect< float > const &)*arg2);
50798     } catch (std::out_of_range& e) {
50799       {
50800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50801       };
50802     } catch (std::exception& e) {
50803       {
50804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50805       };
50806     } catch (Dali::DaliException e) {
50807       {
50808         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50809       };
50810     } catch (...) {
50811       {
50812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50813       };
50814     }
50815   }
50816
50817   jresult = (void *)result;
50818   return jresult;
50819 }
50820
50821
50822 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_Set(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
50823   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50824   float arg2 ;
50825   float arg3 ;
50826   float arg4 ;
50827   float arg5 ;
50828
50829   arg1 = (Dali::Rect< float > *)jarg1;
50830   arg2 = (float)jarg2;
50831   arg3 = (float)jarg3;
50832   arg4 = (float)jarg5;
50833   arg5 = (float)jarg4;
50834   {
50835     try {
50836       (arg1)->Set(arg2,arg3,arg4,arg5);
50837     } catch (std::out_of_range& e) {
50838       {
50839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50840       };
50841     } catch (std::exception& e) {
50842       {
50843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50844       };
50845     } catch (Dali::DaliException e) {
50846       {
50847         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50848       };
50849     } catch (...) {
50850       {
50851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50852       };
50853     }
50854   }
50855
50856 }
50857
50858
50859 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_left_set(void * jarg1, float jarg2) {
50860   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50861   float arg2 ;
50862
50863   arg1 = (Dali::Rect< float > *)jarg1;
50864   arg2 = (float)jarg2;
50865   if (arg1) (arg1)->left = arg2;
50866 }
50867
50868
50869 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_left_get(void * jarg1) {
50870   float jresult ;
50871   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50872   float result;
50873
50874   arg1 = (Dali::Rect< float > *)jarg1;
50875   result = (float) ((arg1)->left);
50876   jresult = result;
50877   return jresult;
50878 }
50879
50880
50881 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_start_set(void * jarg1, float jarg2) {
50882   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50883   float arg2 ;
50884
50885   arg1 = (Dali::Rect< float > *)jarg1;
50886   arg2 = (float)jarg2;
50887   if (arg1) (arg1)->left = arg2;
50888 }
50889
50890
50891 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_start_get(void * jarg1) {
50892   float jresult ;
50893   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50894   float result;
50895
50896   arg1 = (Dali::Rect< float > *)jarg1;
50897   result = (float) ((arg1)->left);
50898   jresult = result;
50899   return jresult;
50900 }
50901
50902
50903 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_right_set(void * jarg1, float jarg2) {
50904   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50905   float arg2 ;
50906
50907   arg1 = (Dali::Rect< float > *)jarg1;
50908   arg2 = (float)jarg2;
50909   if (arg1) (arg1)->right = arg2;
50910 }
50911
50912
50913 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_right_get(void * jarg1) {
50914   float jresult ;
50915   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50916   float result;
50917
50918   arg1 = (Dali::Rect< float > *)jarg1;
50919   result = (float) ((arg1)->right);
50920   jresult = result;
50921   return jresult;
50922 }
50923
50924
50925 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_end_set(void * jarg1, float jarg2) {
50926   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50927   float arg2 ;
50928
50929   arg1 = (Dali::Rect< float > *)jarg1;
50930   arg2 = (float)jarg2;
50931   if (arg1) (arg1)->right = arg2;
50932 }
50933
50934
50935 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_end_get(void * jarg1) {
50936   float jresult ;
50937   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50938   float result;
50939
50940   arg1 = (Dali::Rect< float > *)jarg1;
50941   result = (float) ((arg1)->right);
50942   jresult = result;
50943   return jresult;
50944 }
50945
50946
50947 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_bottom_set(void * jarg1, float jarg2) {
50948   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50949   float arg2 ;
50950
50951   arg1 = (Dali::Rect< float > *)jarg1;
50952   arg2 = (float)jarg2;
50953   if (arg1) (arg1)->bottom = arg2;
50954 }
50955
50956
50957 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_bottom_get(void * jarg1) {
50958   float jresult ;
50959   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50960   float result;
50961
50962   arg1 = (Dali::Rect< float > *)jarg1;
50963   result = (float) ((arg1)->bottom);
50964   jresult = result;
50965   return jresult;
50966 }
50967
50968
50969 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_top_set(void * jarg1, float jarg2) {
50970   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50971   float arg2 ;
50972
50973   arg1 = (Dali::Rect< float > *)jarg1;
50974   arg2 = (float)jarg2;
50975   if (arg1) (arg1)->top = arg2;
50976 }
50977
50978
50979 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_top_get(void * jarg1) {
50980   float jresult ;
50981   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50982   float result;
50983
50984   arg1 = (Dali::Rect< float > *)jarg1;
50985   result = (float) ((arg1)->top);
50986   jresult = result;
50987   return jresult;
50988 }
50989
50990
50991 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PaddingType(void * jarg1) {
50992   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50993
50994   arg1 = (Dali::Rect< float > *)jarg1;
50995   {
50996     try {
50997       delete arg1;
50998     } catch (std::out_of_range& e) {
50999       {
51000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51001       };
51002     } catch (std::exception& e) {
51003       {
51004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51005       };
51006     } catch (Dali::DaliException e) {
51007       {
51008         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51009       };
51010     } catch (...) {
51011       {
51012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51013       };
51014     }
51015   }
51016
51017 }
51018
51019
51020 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorInteger_BaseType_get() {
51021   int jresult ;
51022   int result;
51023
51024   result = (int)Dali::Vector< int >::BaseType;
51025   jresult = (int)result;
51026   return jresult;
51027 }
51028
51029
51030 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_0() {
51031   void * jresult ;
51032   Dali::Vector< int > *result = 0 ;
51033
51034   {
51035     try {
51036       result = (Dali::Vector< int > *)new Dali::Vector< int >();
51037     } catch (std::out_of_range& e) {
51038       {
51039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51040       };
51041     } catch (std::exception& e) {
51042       {
51043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51044       };
51045     } catch (Dali::DaliException e) {
51046       {
51047         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51048       };
51049     } catch (...) {
51050       {
51051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51052       };
51053     }
51054   }
51055
51056   jresult = (void *)result;
51057   return jresult;
51058 }
51059
51060
51061 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorInteger(void * jarg1) {
51062   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51063
51064   arg1 = (Dali::Vector< int > *)jarg1;
51065   {
51066     try {
51067       delete arg1;
51068     } catch (std::out_of_range& e) {
51069       {
51070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51071       };
51072     } catch (std::exception& e) {
51073       {
51074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51075       };
51076     } catch (Dali::DaliException e) {
51077       {
51078         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51079       };
51080     } catch (...) {
51081       {
51082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51083       };
51084     }
51085   }
51086
51087 }
51088
51089
51090 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_1(void * jarg1) {
51091   void * jresult ;
51092   Dali::Vector< int > *arg1 = 0 ;
51093   Dali::Vector< int > *result = 0 ;
51094
51095   arg1 = (Dali::Vector< int > *)jarg1;
51096   if (!arg1) {
51097     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
51098     return 0;
51099   }
51100   {
51101     try {
51102       result = (Dali::Vector< int > *)new Dali::Vector< int >((Dali::Vector< int > const &)*arg1);
51103     } catch (std::out_of_range& e) {
51104       {
51105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51106       };
51107     } catch (std::exception& e) {
51108       {
51109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51110       };
51111     } catch (Dali::DaliException e) {
51112       {
51113         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51114       };
51115     } catch (...) {
51116       {
51117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51118       };
51119     }
51120   }
51121
51122   jresult = (void *)result;
51123   return jresult;
51124 }
51125
51126
51127 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Assign(void * jarg1, void * jarg2) {
51128   void * jresult ;
51129   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51130   Dali::Vector< int > *arg2 = 0 ;
51131   Dali::Vector< int > *result = 0 ;
51132
51133   arg1 = (Dali::Vector< int > *)jarg1;
51134   arg2 = (Dali::Vector< int > *)jarg2;
51135   if (!arg2) {
51136     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
51137     return 0;
51138   }
51139   {
51140     try {
51141       result = (Dali::Vector< int > *) &(arg1)->operator =((Dali::Vector< int > const &)*arg2);
51142     } catch (std::out_of_range& e) {
51143       {
51144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51145       };
51146     } catch (std::exception& e) {
51147       {
51148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51149       };
51150     } catch (Dali::DaliException e) {
51151       {
51152         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51153       };
51154     } catch (...) {
51155       {
51156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51157       };
51158     }
51159   }
51160
51161   jresult = (void *)result;
51162   return jresult;
51163 }
51164
51165
51166 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Begin(void * jarg1) {
51167   void * jresult ;
51168   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51169   Dali::Vector< int >::Iterator result;
51170
51171   arg1 = (Dali::Vector< int > *)jarg1;
51172   {
51173     try {
51174       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->Begin();
51175     } catch (std::out_of_range& e) {
51176       {
51177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51178       };
51179     } catch (std::exception& e) {
51180       {
51181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51182       };
51183     } catch (Dali::DaliException e) {
51184       {
51185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51186       };
51187     } catch (...) {
51188       {
51189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51190       };
51191     }
51192   }
51193
51194   jresult = (void *)result;
51195   return jresult;
51196 }
51197
51198
51199 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_End(void * jarg1) {
51200   void * jresult ;
51201   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51202   Dali::Vector< int >::Iterator result;
51203
51204   arg1 = (Dali::Vector< int > *)jarg1;
51205   {
51206     try {
51207       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->End();
51208     } catch (std::out_of_range& e) {
51209       {
51210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51211       };
51212     } catch (std::exception& e) {
51213       {
51214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51215       };
51216     } catch (Dali::DaliException e) {
51217       {
51218         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51219       };
51220     } catch (...) {
51221       {
51222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51223       };
51224     }
51225   }
51226
51227   jresult = (void *)result;
51228   return jresult;
51229 }
51230
51231
51232 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
51233   void * jresult ;
51234   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51235   Dali::Vector< int >::SizeType arg2 ;
51236   Dali::Vector< int >::ItemType *result = 0 ;
51237
51238   arg1 = (Dali::Vector< int > *)jarg1;
51239   arg2 = (Dali::Vector< int >::SizeType)jarg2;
51240   {
51241     try {
51242       result = (Dali::Vector< int >::ItemType *) &(arg1)->operator [](arg2);
51243     } catch (std::out_of_range& e) {
51244       {
51245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51246       };
51247     } catch (std::exception& e) {
51248       {
51249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51250       };
51251     } catch (Dali::DaliException e) {
51252       {
51253         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51254       };
51255     } catch (...) {
51256       {
51257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51258       };
51259     }
51260   }
51261
51262   jresult = (void *)result;
51263   return jresult;
51264 }
51265
51266
51267 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_PushBack(void * jarg1, int jarg2) {
51268   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51269   Dali::Vector< int >::ItemType *arg2 = 0 ;
51270   Dali::Vector< int >::ItemType temp2 ;
51271
51272   arg1 = (Dali::Vector< int > *)jarg1;
51273   temp2 = (Dali::Vector< int >::ItemType)jarg2;
51274   arg2 = &temp2;
51275   {
51276     try {
51277       (arg1)->PushBack((Dali::Vector< int >::ItemType const &)*arg2);
51278     } catch (std::out_of_range& e) {
51279       {
51280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51281       };
51282     } catch (std::exception& e) {
51283       {
51284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51285       };
51286     } catch (Dali::DaliException e) {
51287       {
51288         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51289       };
51290     } catch (...) {
51291       {
51292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51293       };
51294     }
51295   }
51296
51297 }
51298
51299
51300 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_0(void * jarg1, void * jarg2, int jarg3) {
51301   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51302   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51303   Dali::Vector< int >::ItemType *arg3 = 0 ;
51304   Dali::Vector< int >::ItemType temp3 ;
51305
51306   arg1 = (Dali::Vector< int > *)jarg1;
51307   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51308   temp3 = (Dali::Vector< int >::ItemType)jarg3;
51309   arg3 = &temp3;
51310   {
51311     try {
51312       (arg1)->Insert(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
51313     } catch (std::out_of_range& e) {
51314       {
51315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51316       };
51317     } catch (std::exception& e) {
51318       {
51319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51320       };
51321     } catch (Dali::DaliException e) {
51322       {
51323         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51324       };
51325     } catch (...) {
51326       {
51327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51328       };
51329     }
51330   }
51331
51332 }
51333
51334
51335 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
51336   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51337   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51338   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
51339   Dali::Vector< int >::Iterator arg4 = (Dali::Vector< int >::Iterator) 0 ;
51340
51341   arg1 = (Dali::Vector< int > *)jarg1;
51342   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51343   arg3 = (Dali::Vector< int >::Iterator)jarg3;
51344   arg4 = (Dali::Vector< int >::Iterator)jarg4;
51345   {
51346     try {
51347       (arg1)->Insert(arg2,arg3,arg4);
51348     } catch (std::out_of_range& e) {
51349       {
51350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51351       };
51352     } catch (std::exception& e) {
51353       {
51354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51355       };
51356     } catch (Dali::DaliException e) {
51357       {
51358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51359       };
51360     } catch (...) {
51361       {
51362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51363       };
51364     }
51365   }
51366
51367 }
51368
51369
51370 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Reserve(void * jarg1, unsigned long jarg2) {
51371   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51372   Dali::Vector< int >::SizeType arg2 ;
51373
51374   arg1 = (Dali::Vector< int > *)jarg1;
51375   arg2 = (Dali::Vector< int >::SizeType)jarg2;
51376   {
51377     try {
51378       (arg1)->Reserve(arg2);
51379     } catch (std::out_of_range& e) {
51380       {
51381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51382       };
51383     } catch (std::exception& e) {
51384       {
51385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51386       };
51387     } catch (Dali::DaliException e) {
51388       {
51389         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51390       };
51391     } catch (...) {
51392       {
51393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51394       };
51395     }
51396   }
51397
51398 }
51399
51400
51401 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
51402   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51403   Dali::Vector< int >::SizeType arg2 ;
51404
51405   arg1 = (Dali::Vector< int > *)jarg1;
51406   arg2 = (Dali::Vector< int >::SizeType)jarg2;
51407   {
51408     try {
51409       (arg1)->Resize(arg2);
51410     } catch (std::out_of_range& e) {
51411       {
51412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51413       };
51414     } catch (std::exception& e) {
51415       {
51416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51417       };
51418     } catch (Dali::DaliException e) {
51419       {
51420         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51421       };
51422     } catch (...) {
51423       {
51424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51425       };
51426     }
51427   }
51428
51429 }
51430
51431
51432 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_1(void * jarg1, unsigned long jarg2, int jarg3) {
51433   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51434   Dali::Vector< int >::SizeType arg2 ;
51435   Dali::Vector< int >::ItemType *arg3 = 0 ;
51436   Dali::Vector< int >::ItemType temp3 ;
51437
51438   arg1 = (Dali::Vector< int > *)jarg1;
51439   arg2 = (Dali::Vector< int >::SizeType)jarg2;
51440   temp3 = (Dali::Vector< int >::ItemType)jarg3;
51441   arg3 = &temp3;
51442   {
51443     try {
51444       (arg1)->Resize(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
51445     } catch (std::out_of_range& e) {
51446       {
51447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51448       };
51449     } catch (std::exception& e) {
51450       {
51451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51452       };
51453     } catch (Dali::DaliException e) {
51454       {
51455         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51456       };
51457     } catch (...) {
51458       {
51459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51460       };
51461     }
51462   }
51463
51464 }
51465
51466
51467 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_0(void * jarg1, void * jarg2) {
51468   void * jresult ;
51469   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51470   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51471   Dali::Vector< int >::Iterator result;
51472
51473   arg1 = (Dali::Vector< int > *)jarg1;
51474   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51475   {
51476     try {
51477       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2);
51478     } catch (std::out_of_range& e) {
51479       {
51480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51481       };
51482     } catch (std::exception& e) {
51483       {
51484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51485       };
51486     } catch (Dali::DaliException e) {
51487       {
51488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51489       };
51490     } catch (...) {
51491       {
51492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51493       };
51494     }
51495   }
51496
51497   jresult = (void *)result;
51498   return jresult;
51499 }
51500
51501
51502 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
51503   void * jresult ;
51504   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51505   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51506   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
51507   Dali::Vector< int >::Iterator result;
51508
51509   arg1 = (Dali::Vector< int > *)jarg1;
51510   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51511   arg3 = (Dali::Vector< int >::Iterator)jarg3;
51512   {
51513     try {
51514       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2,arg3);
51515     } catch (std::out_of_range& e) {
51516       {
51517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51518       };
51519     } catch (std::exception& e) {
51520       {
51521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51522       };
51523     } catch (Dali::DaliException e) {
51524       {
51525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51526       };
51527     } catch (...) {
51528       {
51529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51530       };
51531     }
51532   }
51533
51534   jresult = (void *)result;
51535   return jresult;
51536 }
51537
51538
51539 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Remove(void * jarg1, void * jarg2) {
51540   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51541   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51542
51543   arg1 = (Dali::Vector< int > *)jarg1;
51544   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51545   {
51546     try {
51547       (arg1)->Remove(arg2);
51548     } catch (std::out_of_range& e) {
51549       {
51550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51551       };
51552     } catch (std::exception& e) {
51553       {
51554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51555       };
51556     } catch (Dali::DaliException e) {
51557       {
51558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51559       };
51560     } catch (...) {
51561       {
51562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51563       };
51564     }
51565   }
51566
51567 }
51568
51569
51570 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Swap(void * jarg1, void * jarg2) {
51571   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51572   Dali::Vector< int > *arg2 = 0 ;
51573
51574   arg1 = (Dali::Vector< int > *)jarg1;
51575   arg2 = (Dali::Vector< int > *)jarg2;
51576   if (!arg2) {
51577     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > & type is null", 0);
51578     return ;
51579   }
51580   {
51581     try {
51582       (arg1)->Swap(*arg2);
51583     } catch (std::out_of_range& e) {
51584       {
51585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51586       };
51587     } catch (std::exception& e) {
51588       {
51589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51590       };
51591     } catch (Dali::DaliException e) {
51592       {
51593         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51594       };
51595     } catch (...) {
51596       {
51597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51598       };
51599     }
51600   }
51601
51602 }
51603
51604
51605 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Clear(void * jarg1) {
51606   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51607
51608   arg1 = (Dali::Vector< int > *)jarg1;
51609   {
51610     try {
51611       (arg1)->Clear();
51612     } catch (std::out_of_range& e) {
51613       {
51614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51615       };
51616     } catch (std::exception& e) {
51617       {
51618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51619       };
51620     } catch (Dali::DaliException e) {
51621       {
51622         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51623       };
51624     } catch (...) {
51625       {
51626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51627       };
51628     }
51629   }
51630
51631 }
51632
51633
51634 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Release(void * jarg1) {
51635   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51636
51637   arg1 = (Dali::Vector< int > *)jarg1;
51638   {
51639     try {
51640       (arg1)->Release();
51641     } catch (std::out_of_range& e) {
51642       {
51643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51644       };
51645     } catch (std::exception& e) {
51646       {
51647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51648       };
51649     } catch (Dali::DaliException e) {
51650       {
51651         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51652       };
51653     } catch (...) {
51654       {
51655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51656       };
51657     }
51658   }
51659
51660 }
51661
51662
51663 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorFloat_BaseType_get() {
51664   int jresult ;
51665   int result;
51666
51667   result = (int)Dali::Vector< float >::BaseType;
51668   jresult = (int)result;
51669   return jresult;
51670 }
51671
51672
51673 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_0() {
51674   void * jresult ;
51675   Dali::Vector< float > *result = 0 ;
51676
51677   {
51678     try {
51679       result = (Dali::Vector< float > *)new Dali::Vector< float >();
51680     } catch (std::out_of_range& e) {
51681       {
51682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51683       };
51684     } catch (std::exception& e) {
51685       {
51686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51687       };
51688     } catch (Dali::DaliException e) {
51689       {
51690         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51691       };
51692     } catch (...) {
51693       {
51694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51695       };
51696     }
51697   }
51698
51699   jresult = (void *)result;
51700   return jresult;
51701 }
51702
51703
51704 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorFloat(void * jarg1) {
51705   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51706
51707   arg1 = (Dali::Vector< float > *)jarg1;
51708   {
51709     try {
51710       delete arg1;
51711     } catch (std::out_of_range& e) {
51712       {
51713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51714       };
51715     } catch (std::exception& e) {
51716       {
51717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51718       };
51719     } catch (Dali::DaliException e) {
51720       {
51721         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51722       };
51723     } catch (...) {
51724       {
51725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51726       };
51727     }
51728   }
51729
51730 }
51731
51732
51733 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_1(void * jarg1) {
51734   void * jresult ;
51735   Dali::Vector< float > *arg1 = 0 ;
51736   Dali::Vector< float > *result = 0 ;
51737
51738   arg1 = (Dali::Vector< float > *)jarg1;
51739   if (!arg1) {
51740     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
51741     return 0;
51742   }
51743   {
51744     try {
51745       result = (Dali::Vector< float > *)new Dali::Vector< float >((Dali::Vector< float > const &)*arg1);
51746     } catch (std::out_of_range& e) {
51747       {
51748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51749       };
51750     } catch (std::exception& e) {
51751       {
51752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51753       };
51754     } catch (Dali::DaliException e) {
51755       {
51756         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51757       };
51758     } catch (...) {
51759       {
51760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51761       };
51762     }
51763   }
51764
51765   jresult = (void *)result;
51766   return jresult;
51767 }
51768
51769
51770 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Assign(void * jarg1, void * jarg2) {
51771   void * jresult ;
51772   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51773   Dali::Vector< float > *arg2 = 0 ;
51774   Dali::Vector< float > *result = 0 ;
51775
51776   arg1 = (Dali::Vector< float > *)jarg1;
51777   arg2 = (Dali::Vector< float > *)jarg2;
51778   if (!arg2) {
51779     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
51780     return 0;
51781   }
51782   {
51783     try {
51784       result = (Dali::Vector< float > *) &(arg1)->operator =((Dali::Vector< float > const &)*arg2);
51785     } catch (std::out_of_range& e) {
51786       {
51787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51788       };
51789     } catch (std::exception& e) {
51790       {
51791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51792       };
51793     } catch (Dali::DaliException e) {
51794       {
51795         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51796       };
51797     } catch (...) {
51798       {
51799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51800       };
51801     }
51802   }
51803
51804   jresult = (void *)result;
51805   return jresult;
51806 }
51807
51808
51809 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Begin(void * jarg1) {
51810   void * jresult ;
51811   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51812   Dali::Vector< float >::Iterator result;
51813
51814   arg1 = (Dali::Vector< float > *)jarg1;
51815   {
51816     try {
51817       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->Begin();
51818     } catch (std::out_of_range& e) {
51819       {
51820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51821       };
51822     } catch (std::exception& e) {
51823       {
51824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51825       };
51826     } catch (Dali::DaliException e) {
51827       {
51828         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51829       };
51830     } catch (...) {
51831       {
51832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51833       };
51834     }
51835   }
51836
51837   jresult = (void *)result;
51838   return jresult;
51839 }
51840
51841
51842 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_End(void * jarg1) {
51843   void * jresult ;
51844   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51845   Dali::Vector< float >::Iterator result;
51846
51847   arg1 = (Dali::Vector< float > *)jarg1;
51848   {
51849     try {
51850       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->End();
51851     } catch (std::out_of_range& e) {
51852       {
51853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51854       };
51855     } catch (std::exception& e) {
51856       {
51857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51858       };
51859     } catch (Dali::DaliException e) {
51860       {
51861         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51862       };
51863     } catch (...) {
51864       {
51865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51866       };
51867     }
51868   }
51869
51870   jresult = (void *)result;
51871   return jresult;
51872 }
51873
51874
51875 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
51876   void * jresult ;
51877   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51878   Dali::Vector< float >::SizeType arg2 ;
51879   Dali::Vector< float >::ItemType *result = 0 ;
51880
51881   arg1 = (Dali::Vector< float > *)jarg1;
51882   arg2 = (Dali::Vector< float >::SizeType)jarg2;
51883   {
51884     try {
51885       result = (Dali::Vector< float >::ItemType *) &(arg1)->operator [](arg2);
51886     } catch (std::out_of_range& e) {
51887       {
51888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51889       };
51890     } catch (std::exception& e) {
51891       {
51892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51893       };
51894     } catch (Dali::DaliException e) {
51895       {
51896         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51897       };
51898     } catch (...) {
51899       {
51900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51901       };
51902     }
51903   }
51904
51905   jresult = (void *)result;
51906   return jresult;
51907 }
51908
51909
51910 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_PushBack(void * jarg1, float jarg2) {
51911   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51912   Dali::Vector< float >::ItemType *arg2 = 0 ;
51913   Dali::Vector< float >::ItemType temp2 ;
51914
51915   arg1 = (Dali::Vector< float > *)jarg1;
51916   temp2 = (Dali::Vector< float >::ItemType)jarg2;
51917   arg2 = &temp2;
51918   {
51919     try {
51920       (arg1)->PushBack((Dali::Vector< float >::ItemType const &)*arg2);
51921     } catch (std::out_of_range& e) {
51922       {
51923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51924       };
51925     } catch (std::exception& e) {
51926       {
51927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51928       };
51929     } catch (Dali::DaliException e) {
51930       {
51931         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51932       };
51933     } catch (...) {
51934       {
51935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51936       };
51937     }
51938   }
51939
51940 }
51941
51942
51943 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_0(void * jarg1, void * jarg2, float jarg3) {
51944   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51945   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
51946   Dali::Vector< float >::ItemType *arg3 = 0 ;
51947   Dali::Vector< float >::ItemType temp3 ;
51948
51949   arg1 = (Dali::Vector< float > *)jarg1;
51950   arg2 = (Dali::Vector< float >::Iterator)jarg2;
51951   temp3 = (Dali::Vector< float >::ItemType)jarg3;
51952   arg3 = &temp3;
51953   {
51954     try {
51955       (arg1)->Insert(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
51956     } catch (std::out_of_range& e) {
51957       {
51958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51959       };
51960     } catch (std::exception& e) {
51961       {
51962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51963       };
51964     } catch (Dali::DaliException e) {
51965       {
51966         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51967       };
51968     } catch (...) {
51969       {
51970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51971       };
51972     }
51973   }
51974
51975 }
51976
51977
51978 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
51979   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51980   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
51981   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
51982   Dali::Vector< float >::Iterator arg4 = (Dali::Vector< float >::Iterator) 0 ;
51983
51984   arg1 = (Dali::Vector< float > *)jarg1;
51985   arg2 = (Dali::Vector< float >::Iterator)jarg2;
51986   arg3 = (Dali::Vector< float >::Iterator)jarg3;
51987   arg4 = (Dali::Vector< float >::Iterator)jarg4;
51988   {
51989     try {
51990       (arg1)->Insert(arg2,arg3,arg4);
51991     } catch (std::out_of_range& e) {
51992       {
51993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51994       };
51995     } catch (std::exception& e) {
51996       {
51997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51998       };
51999     } catch (Dali::DaliException e) {
52000       {
52001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52002       };
52003     } catch (...) {
52004       {
52005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52006       };
52007     }
52008   }
52009
52010 }
52011
52012
52013 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Reserve(void * jarg1, unsigned long jarg2) {
52014   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52015   Dali::Vector< float >::SizeType arg2 ;
52016
52017   arg1 = (Dali::Vector< float > *)jarg1;
52018   arg2 = (Dali::Vector< float >::SizeType)jarg2;
52019   {
52020     try {
52021       (arg1)->Reserve(arg2);
52022     } catch (std::out_of_range& e) {
52023       {
52024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52025       };
52026     } catch (std::exception& e) {
52027       {
52028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52029       };
52030     } catch (Dali::DaliException e) {
52031       {
52032         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52033       };
52034     } catch (...) {
52035       {
52036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52037       };
52038     }
52039   }
52040
52041 }
52042
52043 //// ========================= end of part 2 =============================
52044
52045 //// ========================== start part 3 ===============================
52046
52047
52048 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
52049   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52050   Dali::Vector< float >::SizeType arg2 ;
52051
52052   arg1 = (Dali::Vector< float > *)jarg1;
52053   arg2 = (Dali::Vector< float >::SizeType)jarg2;
52054   {
52055     try {
52056       (arg1)->Resize(arg2);
52057     } catch (std::out_of_range& e) {
52058       {
52059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52060       };
52061     } catch (std::exception& e) {
52062       {
52063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52064       };
52065     } catch (Dali::DaliException e) {
52066       {
52067         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52068       };
52069     } catch (...) {
52070       {
52071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52072       };
52073     }
52074   }
52075
52076 }
52077
52078
52079 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_1(void * jarg1, unsigned long jarg2, float jarg3) {
52080   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52081   Dali::Vector< float >::SizeType arg2 ;
52082   Dali::Vector< float >::ItemType *arg3 = 0 ;
52083   Dali::Vector< float >::ItemType temp3 ;
52084
52085   arg1 = (Dali::Vector< float > *)jarg1;
52086   arg2 = (Dali::Vector< float >::SizeType)jarg2;
52087   temp3 = (Dali::Vector< float >::ItemType)jarg3;
52088   arg3 = &temp3;
52089   {
52090     try {
52091       (arg1)->Resize(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
52092     } catch (std::out_of_range& e) {
52093       {
52094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52095       };
52096     } catch (std::exception& e) {
52097       {
52098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52099       };
52100     } catch (Dali::DaliException e) {
52101       {
52102         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52103       };
52104     } catch (...) {
52105       {
52106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52107       };
52108     }
52109   }
52110
52111 }
52112
52113
52114 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_0(void * jarg1, void * jarg2) {
52115   void * jresult ;
52116   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52117   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
52118   Dali::Vector< float >::Iterator result;
52119
52120   arg1 = (Dali::Vector< float > *)jarg1;
52121   arg2 = (Dali::Vector< float >::Iterator)jarg2;
52122   {
52123     try {
52124       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2);
52125     } catch (std::out_of_range& e) {
52126       {
52127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52128       };
52129     } catch (std::exception& e) {
52130       {
52131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52132       };
52133     } catch (Dali::DaliException e) {
52134       {
52135         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52136       };
52137     } catch (...) {
52138       {
52139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52140       };
52141     }
52142   }
52143
52144   jresult = (void *)result;
52145   return jresult;
52146 }
52147
52148
52149 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
52150   void * jresult ;
52151   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52152   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
52153   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
52154   Dali::Vector< float >::Iterator result;
52155
52156   arg1 = (Dali::Vector< float > *)jarg1;
52157   arg2 = (Dali::Vector< float >::Iterator)jarg2;
52158   arg3 = (Dali::Vector< float >::Iterator)jarg3;
52159   {
52160     try {
52161       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2,arg3);
52162     } catch (std::out_of_range& e) {
52163       {
52164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52165       };
52166     } catch (std::exception& e) {
52167       {
52168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52169       };
52170     } catch (Dali::DaliException e) {
52171       {
52172         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52173       };
52174     } catch (...) {
52175       {
52176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52177       };
52178     }
52179   }
52180
52181   jresult = (void *)result;
52182   return jresult;
52183 }
52184
52185
52186 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Remove(void * jarg1, void * jarg2) {
52187   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52188   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
52189
52190   arg1 = (Dali::Vector< float > *)jarg1;
52191   arg2 = (Dali::Vector< float >::Iterator)jarg2;
52192   {
52193     try {
52194       (arg1)->Remove(arg2);
52195     } catch (std::out_of_range& e) {
52196       {
52197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52198       };
52199     } catch (std::exception& e) {
52200       {
52201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52202       };
52203     } catch (Dali::DaliException e) {
52204       {
52205         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52206       };
52207     } catch (...) {
52208       {
52209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52210       };
52211     }
52212   }
52213
52214 }
52215
52216
52217 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Swap(void * jarg1, void * jarg2) {
52218   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52219   Dali::Vector< float > *arg2 = 0 ;
52220
52221   arg1 = (Dali::Vector< float > *)jarg1;
52222   arg2 = (Dali::Vector< float > *)jarg2;
52223   if (!arg2) {
52224     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > & type is null", 0);
52225     return ;
52226   }
52227   {
52228     try {
52229       (arg1)->Swap(*arg2);
52230     } catch (std::out_of_range& e) {
52231       {
52232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52233       };
52234     } catch (std::exception& e) {
52235       {
52236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52237       };
52238     } catch (Dali::DaliException e) {
52239       {
52240         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52241       };
52242     } catch (...) {
52243       {
52244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52245       };
52246     }
52247   }
52248
52249 }
52250
52251
52252 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Clear(void * jarg1) {
52253   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52254
52255   arg1 = (Dali::Vector< float > *)jarg1;
52256   {
52257     try {
52258       (arg1)->Clear();
52259     } catch (std::out_of_range& e) {
52260       {
52261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52262       };
52263     } catch (std::exception& e) {
52264       {
52265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52266       };
52267     } catch (Dali::DaliException e) {
52268       {
52269         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52270       };
52271     } catch (...) {
52272       {
52273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52274       };
52275     }
52276   }
52277
52278 }
52279
52280
52281 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Release(void * jarg1) {
52282   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52283
52284   arg1 = (Dali::Vector< float > *)jarg1;
52285   {
52286     try {
52287       (arg1)->Release();
52288     } catch (std::out_of_range& e) {
52289       {
52290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52291       };
52292     } catch (std::exception& e) {
52293       {
52294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52295       };
52296     } catch (Dali::DaliException e) {
52297       {
52298         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52299       };
52300     } catch (...) {
52301       {
52302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52303       };
52304     }
52305   }
52306
52307 }
52308
52309
52310 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_BaseType_get() {
52311   int jresult ;
52312   int result;
52313
52314   result = (int)Dali::Vector< unsigned char >::BaseType;
52315   jresult = (int)result;
52316   return jresult;
52317 }
52318
52319
52320 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_0() {
52321   void * jresult ;
52322   Dali::Vector< unsigned char > *result = 0 ;
52323
52324   {
52325     try {
52326       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >();
52327     } catch (std::out_of_range& e) {
52328       {
52329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52330       };
52331     } catch (std::exception& e) {
52332       {
52333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52334       };
52335     } catch (Dali::DaliException e) {
52336       {
52337         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52338       };
52339     } catch (...) {
52340       {
52341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52342       };
52343     }
52344   }
52345
52346   jresult = (void *)result;
52347   return jresult;
52348 }
52349
52350
52351 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUnsignedChar(void * jarg1) {
52352   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52353
52354   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52355   {
52356     try {
52357       delete arg1;
52358     } catch (std::out_of_range& e) {
52359       {
52360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52361       };
52362     } catch (std::exception& e) {
52363       {
52364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52365       };
52366     } catch (Dali::DaliException e) {
52367       {
52368         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52369       };
52370     } catch (...) {
52371       {
52372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52373       };
52374     }
52375   }
52376
52377 }
52378
52379
52380 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_1(void * jarg1) {
52381   void * jresult ;
52382   Dali::Vector< unsigned char > *arg1 = 0 ;
52383   Dali::Vector< unsigned char > *result = 0 ;
52384
52385   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52386   if (!arg1) {
52387     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
52388     return 0;
52389   }
52390   {
52391     try {
52392       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >((Dali::Vector< unsigned char > const &)*arg1);
52393     } catch (std::out_of_range& e) {
52394       {
52395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52396       };
52397     } catch (std::exception& e) {
52398       {
52399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52400       };
52401     } catch (Dali::DaliException e) {
52402       {
52403         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52404       };
52405     } catch (...) {
52406       {
52407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52408       };
52409     }
52410   }
52411
52412   jresult = (void *)result;
52413   return jresult;
52414 }
52415
52416
52417 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Assign(void * jarg1, void * jarg2) {
52418   void * jresult ;
52419   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52420   Dali::Vector< unsigned char > *arg2 = 0 ;
52421   Dali::Vector< unsigned char > *result = 0 ;
52422
52423   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52424   arg2 = (Dali::Vector< unsigned char > *)jarg2;
52425   if (!arg2) {
52426     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
52427     return 0;
52428   }
52429   {
52430     try {
52431       result = (Dali::Vector< unsigned char > *) &(arg1)->operator =((Dali::Vector< unsigned char > const &)*arg2);
52432     } catch (std::out_of_range& e) {
52433       {
52434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52435       };
52436     } catch (std::exception& e) {
52437       {
52438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52439       };
52440     } catch (Dali::DaliException e) {
52441       {
52442         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52443       };
52444     } catch (...) {
52445       {
52446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52447       };
52448     }
52449   }
52450
52451   jresult = (void *)result;
52452   return jresult;
52453 }
52454
52455
52456 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Begin(void * jarg1) {
52457   void * jresult ;
52458   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52459   Dali::Vector< unsigned char >::Iterator result;
52460
52461   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52462   {
52463     try {
52464       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->Begin();
52465     } catch (std::out_of_range& e) {
52466       {
52467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52468       };
52469     } catch (std::exception& e) {
52470       {
52471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52472       };
52473     } catch (Dali::DaliException e) {
52474       {
52475         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52476       };
52477     } catch (...) {
52478       {
52479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52480       };
52481     }
52482   }
52483
52484   jresult = (void *)result;
52485   return jresult;
52486 }
52487
52488
52489 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_End(void * jarg1) {
52490   void * jresult ;
52491   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52492   Dali::Vector< unsigned char >::Iterator result;
52493
52494   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52495   {
52496     try {
52497       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->End();
52498     } catch (std::out_of_range& e) {
52499       {
52500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52501       };
52502     } catch (std::exception& e) {
52503       {
52504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52505       };
52506     } catch (Dali::DaliException e) {
52507       {
52508         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52509       };
52510     } catch (...) {
52511       {
52512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52513       };
52514     }
52515   }
52516
52517   jresult = (void *)result;
52518   return jresult;
52519 }
52520
52521
52522 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
52523   void * jresult ;
52524   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52525   Dali::Vector< unsigned char >::SizeType arg2 ;
52526   Dali::Vector< unsigned char >::ItemType *result = 0 ;
52527
52528   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52529   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
52530   {
52531     try {
52532       result = (Dali::Vector< unsigned char >::ItemType *) &(arg1)->operator [](arg2);
52533     } catch (std::out_of_range& e) {
52534       {
52535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52536       };
52537     } catch (std::exception& e) {
52538       {
52539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52540       };
52541     } catch (Dali::DaliException e) {
52542       {
52543         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52544       };
52545     } catch (...) {
52546       {
52547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52548       };
52549     }
52550   }
52551
52552   jresult = (void *)result;
52553   return jresult;
52554 }
52555
52556
52557 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_PushBack(void * jarg1, unsigned char jarg2) {
52558   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52559   Dali::Vector< unsigned char >::ItemType *arg2 = 0 ;
52560   Dali::Vector< unsigned char >::ItemType temp2 ;
52561
52562   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52563   temp2 = (Dali::Vector< unsigned char >::ItemType)jarg2;
52564   arg2 = &temp2;
52565   {
52566     try {
52567       (arg1)->PushBack((Dali::Vector< unsigned char >::ItemType const &)*arg2);
52568     } catch (std::out_of_range& e) {
52569       {
52570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52571       };
52572     } catch (std::exception& e) {
52573       {
52574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52575       };
52576     } catch (Dali::DaliException e) {
52577       {
52578         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52579       };
52580     } catch (...) {
52581       {
52582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52583       };
52584     }
52585   }
52586
52587 }
52588
52589
52590 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_0(void * jarg1, unsigned char* jarg2, unsigned char jarg3) {
52591   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52592   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52593   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
52594   Dali::Vector< unsigned char >::ItemType temp3 ;
52595
52596   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52597   arg2 = jarg2;
52598   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
52599   arg3 = &temp3;
52600   {
52601     try {
52602       (arg1)->Insert(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
52603     } catch (std::out_of_range& e) {
52604       {
52605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52606       };
52607     } catch (std::exception& e) {
52608       {
52609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52610       };
52611     } catch (Dali::DaliException e) {
52612       {
52613         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52614       };
52615     } catch (...) {
52616       {
52617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52618       };
52619     }
52620   }
52621
52622
52623
52624 }
52625
52626
52627 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3, void * jarg4) {
52628   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52629   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52630   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52631   Dali::Vector< unsigned char >::Iterator arg4 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52632
52633   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52634   arg2 = jarg2;
52635   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
52636   arg4 = (Dali::Vector< unsigned char >::Iterator)jarg4;
52637   {
52638     try {
52639       (arg1)->Insert(arg2,arg3,arg4);
52640     } catch (std::out_of_range& e) {
52641       {
52642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52643       };
52644     } catch (std::exception& e) {
52645       {
52646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52647       };
52648     } catch (Dali::DaliException e) {
52649       {
52650         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52651       };
52652     } catch (...) {
52653       {
52654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52655       };
52656     }
52657   }
52658
52659
52660
52661 }
52662
52663
52664 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Reserve(void * jarg1, unsigned long jarg2) {
52665   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52666   Dali::Vector< unsigned char >::SizeType arg2 ;
52667
52668   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52669   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
52670   {
52671     try {
52672       (arg1)->Reserve(arg2);
52673     } catch (std::out_of_range& e) {
52674       {
52675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52676       };
52677     } catch (std::exception& e) {
52678       {
52679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52680       };
52681     } catch (Dali::DaliException e) {
52682       {
52683         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52684       };
52685     } catch (...) {
52686       {
52687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52688       };
52689     }
52690   }
52691
52692 }
52693
52694
52695 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
52696   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52697   Dali::Vector< unsigned char >::SizeType arg2 ;
52698
52699   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52700   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
52701   {
52702     try {
52703       (arg1)->Resize(arg2);
52704     } catch (std::out_of_range& e) {
52705       {
52706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52707       };
52708     } catch (std::exception& e) {
52709       {
52710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52711       };
52712     } catch (Dali::DaliException e) {
52713       {
52714         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52715       };
52716     } catch (...) {
52717       {
52718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52719       };
52720     }
52721   }
52722
52723 }
52724
52725
52726 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_1(void * jarg1, unsigned long jarg2, unsigned char jarg3) {
52727   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52728   Dali::Vector< unsigned char >::SizeType arg2 ;
52729   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
52730   Dali::Vector< unsigned char >::ItemType temp3 ;
52731
52732   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52733   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
52734   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
52735   arg3 = &temp3;
52736   {
52737     try {
52738       (arg1)->Resize(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
52739     } catch (std::out_of_range& e) {
52740       {
52741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52742       };
52743     } catch (std::exception& e) {
52744       {
52745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52746       };
52747     } catch (Dali::DaliException e) {
52748       {
52749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52750       };
52751     } catch (...) {
52752       {
52753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52754       };
52755     }
52756   }
52757
52758 }
52759
52760
52761 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_0(void * jarg1, unsigned char* jarg2) {
52762   void * jresult ;
52763   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52764   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52765   Dali::Vector< unsigned char >::Iterator result;
52766
52767   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52768   arg2 = jarg2;
52769   {
52770     try {
52771       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2);
52772     } catch (std::out_of_range& e) {
52773       {
52774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52775       };
52776     } catch (std::exception& e) {
52777       {
52778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52779       };
52780     } catch (Dali::DaliException e) {
52781       {
52782         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52783       };
52784     } catch (...) {
52785       {
52786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52787       };
52788     }
52789   }
52790
52791   jresult = (void *)result;
52792
52793
52794   return jresult;
52795 }
52796
52797
52798 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3) {
52799   void * jresult ;
52800   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52801   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52802   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52803   Dali::Vector< unsigned char >::Iterator result;
52804
52805   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52806   arg2 = jarg2;
52807   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
52808   {
52809     try {
52810       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2,arg3);
52811     } catch (std::out_of_range& e) {
52812       {
52813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52814       };
52815     } catch (std::exception& e) {
52816       {
52817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52818       };
52819     } catch (Dali::DaliException e) {
52820       {
52821         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52822       };
52823     } catch (...) {
52824       {
52825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52826       };
52827     }
52828   }
52829
52830   jresult = (void *)result;
52831
52832
52833   return jresult;
52834 }
52835
52836
52837 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Remove(void * jarg1, unsigned char* jarg2) {
52838   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52839   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52840
52841   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52842   arg2 = jarg2;
52843   {
52844     try {
52845       (arg1)->Remove(arg2);
52846     } catch (std::out_of_range& e) {
52847       {
52848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52849       };
52850     } catch (std::exception& e) {
52851       {
52852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52853       };
52854     } catch (Dali::DaliException e) {
52855       {
52856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52857       };
52858     } catch (...) {
52859       {
52860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52861       };
52862     }
52863   }
52864
52865
52866
52867 }
52868
52869
52870 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Swap(void * jarg1, void * jarg2) {
52871   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52872   Dali::Vector< unsigned char > *arg2 = 0 ;
52873
52874   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52875   arg2 = (Dali::Vector< unsigned char > *)jarg2;
52876   if (!arg2) {
52877     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > & type is null", 0);
52878     return ;
52879   }
52880   {
52881     try {
52882       (arg1)->Swap(*arg2);
52883     } catch (std::out_of_range& e) {
52884       {
52885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52886       };
52887     } catch (std::exception& e) {
52888       {
52889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52890       };
52891     } catch (Dali::DaliException e) {
52892       {
52893         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52894       };
52895     } catch (...) {
52896       {
52897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52898       };
52899     }
52900   }
52901
52902 }
52903
52904
52905 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Clear(void * jarg1) {
52906   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52907
52908   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52909   {
52910     try {
52911       (arg1)->Clear();
52912     } catch (std::out_of_range& e) {
52913       {
52914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52915       };
52916     } catch (std::exception& e) {
52917       {
52918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52919       };
52920     } catch (Dali::DaliException e) {
52921       {
52922         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52923       };
52924     } catch (...) {
52925       {
52926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52927       };
52928     }
52929   }
52930
52931 }
52932
52933
52934 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Release(void * jarg1) {
52935   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52936
52937   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52938   {
52939     try {
52940       (arg1)->Release();
52941     } catch (std::out_of_range& e) {
52942       {
52943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52944       };
52945     } catch (std::exception& e) {
52946       {
52947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52948       };
52949     } catch (Dali::DaliException e) {
52950       {
52951         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52952       };
52953     } catch (...) {
52954       {
52955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52956       };
52957     }
52958   }
52959
52960 }
52961
52962
52963 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUint16Pair_BaseType_get() {
52964   int jresult ;
52965   int result;
52966
52967   result = (int)Dali::Vector< Dali::Uint16Pair >::BaseType;
52968   jresult = (int)result;
52969   return jresult;
52970 }
52971
52972
52973 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_0() {
52974   void * jresult ;
52975   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
52976
52977   {
52978     try {
52979       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >();
52980     } catch (std::out_of_range& e) {
52981       {
52982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52983       };
52984     } catch (std::exception& e) {
52985       {
52986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52987       };
52988     } catch (Dali::DaliException e) {
52989       {
52990         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52991       };
52992     } catch (...) {
52993       {
52994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52995       };
52996     }
52997   }
52998
52999   jresult = (void *)result;
53000   return jresult;
53001 }
53002
53003
53004 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUint16Pair(void * jarg1) {
53005   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53006
53007   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53008   {
53009     try {
53010       delete arg1;
53011     } catch (std::out_of_range& e) {
53012       {
53013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53014       };
53015     } catch (std::exception& e) {
53016       {
53017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53018       };
53019     } catch (Dali::DaliException e) {
53020       {
53021         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53022       };
53023     } catch (...) {
53024       {
53025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53026       };
53027     }
53028   }
53029
53030 }
53031
53032
53033 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_1(void * jarg1) {
53034   void * jresult ;
53035   Dali::Vector< Dali::Uint16Pair > *arg1 = 0 ;
53036   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
53037
53038   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53039   if (!arg1) {
53040     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
53041     return 0;
53042   }
53043   {
53044     try {
53045       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >((Dali::Vector< Dali::Uint16Pair > const &)*arg1);
53046     } catch (std::out_of_range& e) {
53047       {
53048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53049       };
53050     } catch (std::exception& e) {
53051       {
53052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53053       };
53054     } catch (Dali::DaliException e) {
53055       {
53056         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53057       };
53058     } catch (...) {
53059       {
53060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53061       };
53062     }
53063   }
53064
53065   jresult = (void *)result;
53066   return jresult;
53067 }
53068
53069
53070 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Assign(void * jarg1, void * jarg2) {
53071   void * jresult ;
53072   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53073   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
53074   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
53075
53076   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53077   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
53078   if (!arg2) {
53079     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
53080     return 0;
53081   }
53082   {
53083     try {
53084       result = (Dali::Vector< Dali::Uint16Pair > *) &(arg1)->operator =((Dali::Vector< Dali::Uint16Pair > const &)*arg2);
53085     } catch (std::out_of_range& e) {
53086       {
53087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53088       };
53089     } catch (std::exception& e) {
53090       {
53091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53092       };
53093     } catch (Dali::DaliException e) {
53094       {
53095         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53096       };
53097     } catch (...) {
53098       {
53099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53100       };
53101     }
53102   }
53103
53104   jresult = (void *)result;
53105   return jresult;
53106 }
53107
53108
53109 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Begin(void * jarg1) {
53110   void * jresult ;
53111   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53112   Dali::Vector< Dali::Uint16Pair >::Iterator result;
53113
53114   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53115   {
53116     try {
53117       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->Begin();
53118     } catch (std::out_of_range& e) {
53119       {
53120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53121       };
53122     } catch (std::exception& e) {
53123       {
53124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53125       };
53126     } catch (Dali::DaliException e) {
53127       {
53128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53129       };
53130     } catch (...) {
53131       {
53132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53133       };
53134     }
53135   }
53136
53137   jresult = (void *)result;
53138   return jresult;
53139 }
53140
53141
53142 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_End(void * jarg1) {
53143   void * jresult ;
53144   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53145   Dali::Vector< Dali::Uint16Pair >::Iterator result;
53146
53147   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53148   {
53149     try {
53150       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->End();
53151     } catch (std::out_of_range& e) {
53152       {
53153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53154       };
53155     } catch (std::exception& e) {
53156       {
53157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53158       };
53159     } catch (Dali::DaliException e) {
53160       {
53161         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53162       };
53163     } catch (...) {
53164       {
53165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53166       };
53167     }
53168   }
53169
53170   jresult = (void *)result;
53171   return jresult;
53172 }
53173
53174
53175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
53176   void * jresult ;
53177   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53178   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
53179   Dali::Vector< Dali::Uint16Pair >::ItemType *result = 0 ;
53180
53181   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53182   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
53183   {
53184     try {
53185       result = (Dali::Vector< Dali::Uint16Pair >::ItemType *) &(arg1)->operator [](arg2);
53186     } catch (std::out_of_range& e) {
53187       {
53188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53189       };
53190     } catch (std::exception& e) {
53191       {
53192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53193       };
53194     } catch (Dali::DaliException e) {
53195       {
53196         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53197       };
53198     } catch (...) {
53199       {
53200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53201       };
53202     }
53203   }
53204
53205   jresult = (void *)result;
53206   return jresult;
53207 }
53208
53209
53210 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_PushBack(void * jarg1, void * jarg2) {
53211   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53212   Dali::Vector< Dali::Uint16Pair >::ItemType *arg2 = 0 ;
53213
53214   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53215   arg2 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg2;
53216   if (!arg2) {
53217     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
53218     return ;
53219   }
53220   {
53221     try {
53222       (arg1)->PushBack((Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg2);
53223     } catch (std::out_of_range& e) {
53224       {
53225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53226       };
53227     } catch (std::exception& e) {
53228       {
53229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53230       };
53231     } catch (Dali::DaliException e) {
53232       {
53233         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53234       };
53235     } catch (...) {
53236       {
53237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53238       };
53239     }
53240   }
53241
53242 }
53243
53244
53245 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
53246   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53247   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53248   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
53249
53250   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53251   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53252   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
53253   if (!arg3) {
53254     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
53255     return ;
53256   }
53257   {
53258     try {
53259       (arg1)->Insert(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
53260     } catch (std::out_of_range& e) {
53261       {
53262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53263       };
53264     } catch (std::exception& e) {
53265       {
53266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53267       };
53268     } catch (Dali::DaliException e) {
53269       {
53270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53271       };
53272     } catch (...) {
53273       {
53274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53275       };
53276     }
53277   }
53278
53279 }
53280
53281
53282 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
53283   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53284   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53285   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53286   Dali::Vector< Dali::Uint16Pair >::Iterator arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53287
53288   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53289   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53290   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
53291   arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg4;
53292   {
53293     try {
53294       (arg1)->Insert(arg2,arg3,arg4);
53295     } catch (std::out_of_range& e) {
53296       {
53297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53298       };
53299     } catch (std::exception& e) {
53300       {
53301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53302       };
53303     } catch (Dali::DaliException e) {
53304       {
53305         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53306       };
53307     } catch (...) {
53308       {
53309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53310       };
53311     }
53312   }
53313
53314 }
53315
53316
53317 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Reserve(void * jarg1, unsigned long jarg2) {
53318   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53319   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
53320
53321   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53322   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
53323   {
53324     try {
53325       (arg1)->Reserve(arg2);
53326     } catch (std::out_of_range& e) {
53327       {
53328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53329       };
53330     } catch (std::exception& e) {
53331       {
53332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53333       };
53334     } catch (Dali::DaliException e) {
53335       {
53336         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53337       };
53338     } catch (...) {
53339       {
53340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53341       };
53342     }
53343   }
53344
53345 }
53346
53347
53348 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
53349   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53350   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
53351
53352   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53353   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
53354   {
53355     try {
53356       (arg1)->Resize(arg2);
53357     } catch (std::out_of_range& e) {
53358       {
53359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53360       };
53361     } catch (std::exception& e) {
53362       {
53363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53364       };
53365     } catch (Dali::DaliException e) {
53366       {
53367         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53368       };
53369     } catch (...) {
53370       {
53371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53372       };
53373     }
53374   }
53375
53376 }
53377
53378
53379 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3) {
53380   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53381   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
53382   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
53383
53384   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53385   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
53386   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
53387   if (!arg3) {
53388     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
53389     return ;
53390   }
53391   {
53392     try {
53393       (arg1)->Resize(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
53394     } catch (std::out_of_range& e) {
53395       {
53396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53397       };
53398     } catch (std::exception& e) {
53399       {
53400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53401       };
53402     } catch (Dali::DaliException e) {
53403       {
53404         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53405       };
53406     } catch (...) {
53407       {
53408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53409       };
53410     }
53411   }
53412
53413 }
53414
53415
53416 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_0(void * jarg1, void * jarg2) {
53417   void * jresult ;
53418   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53419   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53420   Dali::Vector< Dali::Uint16Pair >::Iterator result;
53421
53422   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53423   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53424   {
53425     try {
53426       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2);
53427     } catch (std::out_of_range& e) {
53428       {
53429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53430       };
53431     } catch (std::exception& e) {
53432       {
53433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53434       };
53435     } catch (Dali::DaliException e) {
53436       {
53437         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53438       };
53439     } catch (...) {
53440       {
53441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53442       };
53443     }
53444   }
53445
53446   jresult = (void *)result;
53447   return jresult;
53448 }
53449
53450
53451 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
53452   void * jresult ;
53453   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53454   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53455   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53456   Dali::Vector< Dali::Uint16Pair >::Iterator result;
53457
53458   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53459   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53460   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
53461   {
53462     try {
53463       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2,arg3);
53464     } catch (std::out_of_range& e) {
53465       {
53466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53467       };
53468     } catch (std::exception& e) {
53469       {
53470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53471       };
53472     } catch (Dali::DaliException e) {
53473       {
53474         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53475       };
53476     } catch (...) {
53477       {
53478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53479       };
53480     }
53481   }
53482
53483   jresult = (void *)result;
53484   return jresult;
53485 }
53486
53487
53488 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Remove(void * jarg1, void * jarg2) {
53489   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53490   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53491
53492   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53493   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53494   {
53495     try {
53496       (arg1)->Remove(arg2);
53497     } catch (std::out_of_range& e) {
53498       {
53499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53500       };
53501     } catch (std::exception& e) {
53502       {
53503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53504       };
53505     } catch (Dali::DaliException e) {
53506       {
53507         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53508       };
53509     } catch (...) {
53510       {
53511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53512       };
53513     }
53514   }
53515
53516 }
53517
53518
53519 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Swap(void * jarg1, void * jarg2) {
53520   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53521   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
53522
53523   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53524   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
53525   if (!arg2) {
53526     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > & type is null", 0);
53527     return ;
53528   }
53529   {
53530     try {
53531       (arg1)->Swap(*arg2);
53532     } catch (std::out_of_range& e) {
53533       {
53534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53535       };
53536     } catch (std::exception& e) {
53537       {
53538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53539       };
53540     } catch (Dali::DaliException e) {
53541       {
53542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53543       };
53544     } catch (...) {
53545       {
53546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53547       };
53548     }
53549   }
53550
53551 }
53552
53553
53554 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Clear(void * jarg1) {
53555   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53556
53557   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53558   {
53559     try {
53560       (arg1)->Clear();
53561     } catch (std::out_of_range& e) {
53562       {
53563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53564       };
53565     } catch (std::exception& e) {
53566       {
53567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53568       };
53569     } catch (Dali::DaliException e) {
53570       {
53571         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53572       };
53573     } catch (...) {
53574       {
53575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53576       };
53577     }
53578   }
53579
53580 }
53581
53582
53583 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Release(void * jarg1) {
53584   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53585
53586   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53587   {
53588     try {
53589       (arg1)->Release();
53590     } catch (std::out_of_range& e) {
53591       {
53592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53593       };
53594     } catch (std::exception& e) {
53595       {
53596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53597       };
53598     } catch (Dali::DaliException e) {
53599       {
53600         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53601       };
53602     } catch (...) {
53603       {
53604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53605       };
53606     }
53607   }
53608
53609 }
53610
53611
53612 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VoidSignal() {
53613   void * jresult ;
53614   Dali::Signal< void () > *result = 0 ;
53615
53616   {
53617     try {
53618       result = (Dali::Signal< void () > *)new Dali::Signal< void () >();
53619     } catch (std::out_of_range& e) {
53620       {
53621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53622       };
53623     } catch (std::exception& e) {
53624       {
53625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53626       };
53627     } catch (Dali::DaliException e) {
53628       {
53629         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53630       };
53631     } catch (...) {
53632       {
53633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53634       };
53635     }
53636   }
53637
53638   jresult = (void *)result;
53639   return jresult;
53640 }
53641
53642
53643 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VoidSignal(void * jarg1) {
53644   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53645
53646   arg1 = (Dali::Signal< void () > *)jarg1;
53647   {
53648     try {
53649       delete arg1;
53650     } catch (std::out_of_range& e) {
53651       {
53652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53653       };
53654     } catch (std::exception& e) {
53655       {
53656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53657       };
53658     } catch (Dali::DaliException e) {
53659       {
53660         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53661       };
53662     } catch (...) {
53663       {
53664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53665       };
53666     }
53667   }
53668
53669 }
53670
53671
53672 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VoidSignal_Empty(void * jarg1) {
53673   unsigned int jresult ;
53674   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53675   bool result;
53676
53677   arg1 = (Dali::Signal< void () > *)jarg1;
53678   {
53679     try {
53680       result = (bool)((Dali::Signal< void () > const *)arg1)->Empty();
53681     } catch (std::out_of_range& e) {
53682       {
53683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53684       };
53685     } catch (std::exception& e) {
53686       {
53687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53688       };
53689     } catch (Dali::DaliException e) {
53690       {
53691         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53692       };
53693     } catch (...) {
53694       {
53695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53696       };
53697     }
53698   }
53699
53700   jresult = result;
53701   return jresult;
53702 }
53703
53704
53705 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VoidSignal_GetConnectionCount(void * jarg1) {
53706   unsigned long jresult ;
53707   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53708   std::size_t result;
53709
53710   arg1 = (Dali::Signal< void () > *)jarg1;
53711   {
53712     try {
53713       result = ((Dali::Signal< void () > const *)arg1)->GetConnectionCount();
53714     } catch (std::out_of_range& e) {
53715       {
53716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53717       };
53718     } catch (std::exception& e) {
53719       {
53720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53721       };
53722     } catch (Dali::DaliException e) {
53723       {
53724         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53725       };
53726     } catch (...) {
53727       {
53728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53729       };
53730     }
53731   }
53732
53733   jresult = (unsigned long)result;
53734   return jresult;
53735 }
53736
53737
53738 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_0(void * jarg1, void * jarg2) {
53739   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53740   void (*arg2)() = (void (*)()) 0 ;
53741
53742   arg1 = (Dali::Signal< void () > *)jarg1;
53743   arg2 = (void (*)())jarg2;
53744   {
53745     try {
53746       (arg1)->Connect(arg2);
53747     } catch (std::out_of_range& e) {
53748       {
53749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53750       };
53751     } catch (std::exception& e) {
53752       {
53753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53754       };
53755     } catch (Dali::DaliException e) {
53756       {
53757         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53758       };
53759     } catch (...) {
53760       {
53761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53762       };
53763     }
53764   }
53765
53766 }
53767
53768
53769 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Disconnect(void * jarg1, void * jarg2) {
53770   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53771   void (*arg2)() = (void (*)()) 0 ;
53772
53773   arg1 = (Dali::Signal< void () > *)jarg1;
53774   arg2 = (void (*)())jarg2;
53775   {
53776     try {
53777       (arg1)->Disconnect(arg2);
53778     } catch (std::out_of_range& e) {
53779       {
53780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53781       };
53782     } catch (std::exception& e) {
53783       {
53784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53785       };
53786     } catch (Dali::DaliException e) {
53787       {
53788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53789       };
53790     } catch (...) {
53791       {
53792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53793       };
53794     }
53795   }
53796
53797 }
53798
53799
53800 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
53801   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53802   Dali::ConnectionTrackerInterface *arg2 = (Dali::ConnectionTrackerInterface *) 0 ;
53803   Dali::FunctorDelegate *arg3 = (Dali::FunctorDelegate *) 0 ;
53804
53805   arg1 = (Dali::Signal< void () > *)jarg1;
53806   arg2 = (Dali::ConnectionTrackerInterface *)jarg2;
53807   arg3 = (Dali::FunctorDelegate *)jarg3;
53808   {
53809     try {
53810       (arg1)->Connect(arg2,arg3);
53811     } catch (std::out_of_range& e) {
53812       {
53813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53814       };
53815     } catch (std::exception& e) {
53816       {
53817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53818       };
53819     } catch (Dali::DaliException e) {
53820       {
53821         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53822       };
53823     } catch (...) {
53824       {
53825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53826       };
53827     }
53828   }
53829
53830 }
53831
53832
53833 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Emit(void * jarg1) {
53834   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53835
53836   arg1 = (Dali::Signal< void () > *)jarg1;
53837   {
53838     try {
53839       (arg1)->Emit();
53840     } catch (std::out_of_range& e) {
53841       {
53842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53843       };
53844     } catch (std::exception& e) {
53845       {
53846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53847       };
53848     } catch (Dali::DaliException e) {
53849       {
53850         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53851       };
53852     } catch (...) {
53853       {
53854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53855       };
53856     }
53857   }
53858
53859 }
53860
53861
53862 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FloatSignal_Empty(void * jarg1) {
53863   unsigned int jresult ;
53864   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
53865   bool result;
53866
53867   arg1 = (Dali::Signal< void (float) > *)jarg1;
53868   {
53869     try {
53870       result = (bool)Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty((Dali::Signal< void (float) > const *)arg1);
53871     } catch (std::out_of_range& e) {
53872       {
53873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53874       };
53875     } catch (std::exception& e) {
53876       {
53877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53878       };
53879     } catch (Dali::DaliException e) {
53880       {
53881         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53882       };
53883     } catch (...) {
53884       {
53885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53886       };
53887     }
53888   }
53889
53890   jresult = result;
53891   return jresult;
53892 }
53893
53894
53895 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FloatSignal_GetConnectionCount(void * jarg1) {
53896   unsigned long jresult ;
53897   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
53898   std::size_t result;
53899
53900   arg1 = (Dali::Signal< void (float) > *)jarg1;
53901   {
53902     try {
53903       result = Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount((Dali::Signal< void (float) > const *)arg1);
53904     } catch (std::out_of_range& e) {
53905       {
53906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53907       };
53908     } catch (std::exception& e) {
53909       {
53910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53911       };
53912     } catch (Dali::DaliException e) {
53913       {
53914         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53915       };
53916     } catch (...) {
53917       {
53918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53919       };
53920     }
53921   }
53922
53923   jresult = (unsigned long)result;
53924   return jresult;
53925 }
53926
53927
53928 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Connect(void * jarg1, void * jarg2) {
53929   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
53930   void (*arg2)(float) = (void (*)(float)) 0 ;
53931
53932   arg1 = (Dali::Signal< void (float) > *)jarg1;
53933   arg2 = (void (*)(float))jarg2;
53934   {
53935     try {
53936       Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(arg1,arg2);
53937     } catch (std::out_of_range& e) {
53938       {
53939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53940       };
53941     } catch (std::exception& e) {
53942       {
53943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53944       };
53945     } catch (Dali::DaliException e) {
53946       {
53947         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53948       };
53949     } catch (...) {
53950       {
53951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53952       };
53953     }
53954   }
53955
53956 }
53957
53958
53959 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Disconnect(void * jarg1, void * jarg2) {
53960   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
53961   void (*arg2)(float) = (void (*)(float)) 0 ;
53962
53963   arg1 = (Dali::Signal< void (float) > *)jarg1;
53964   arg2 = (void (*)(float))jarg2;
53965   {
53966     try {
53967       Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(arg1,arg2);
53968     } catch (std::out_of_range& e) {
53969       {
53970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53971       };
53972     } catch (std::exception& e) {
53973       {
53974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53975       };
53976     } catch (Dali::DaliException e) {
53977       {
53978         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53979       };
53980     } catch (...) {
53981       {
53982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53983       };
53984     }
53985   }
53986
53987 }
53988
53989
53990 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Emit(void * jarg1, float jarg2) {
53991   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
53992   float arg2 ;
53993
53994   arg1 = (Dali::Signal< void (float) > *)jarg1;
53995   arg2 = (float)jarg2;
53996   {
53997     try {
53998       Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(arg1,arg2);
53999     } catch (std::out_of_range& e) {
54000       {
54001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54002       };
54003     } catch (std::exception& e) {
54004       {
54005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54006       };
54007     } catch (Dali::DaliException e) {
54008       {
54009         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54010       };
54011     } catch (...) {
54012       {
54013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54014       };
54015     }
54016   }
54017
54018 }
54019
54020
54021 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FloatSignal() {
54022   void * jresult ;
54023   Dali::Signal< void (float) > *result = 0 ;
54024
54025   {
54026     try {
54027       result = (Dali::Signal< void (float) > *)new Dali::Signal< void (float) >();
54028     } catch (std::out_of_range& e) {
54029       {
54030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54031       };
54032     } catch (std::exception& e) {
54033       {
54034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54035       };
54036     } catch (Dali::DaliException e) {
54037       {
54038         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54039       };
54040     } catch (...) {
54041       {
54042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54043       };
54044     }
54045   }
54046
54047   jresult = (void *)result;
54048   return jresult;
54049 }
54050
54051
54052 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FloatSignal(void * jarg1) {
54053   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
54054
54055   arg1 = (Dali::Signal< void (float) > *)jarg1;
54056   {
54057     try {
54058       delete arg1;
54059     } catch (std::out_of_range& e) {
54060       {
54061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54062       };
54063     } catch (std::exception& e) {
54064       {
54065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54066       };
54067     } catch (Dali::DaliException e) {
54068       {
54069         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54070       };
54071     } catch (...) {
54072       {
54073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54074       };
54075     }
54076   }
54077
54078 }
54079
54080
54081 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Empty(void * jarg1) {
54082   unsigned int jresult ;
54083   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54084   bool result;
54085
54086   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54087   {
54088     try {
54089       result = (bool)Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
54090     } catch (std::out_of_range& e) {
54091       {
54092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54093       };
54094     } catch (std::exception& e) {
54095       {
54096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54097       };
54098     } catch (Dali::DaliException e) {
54099       {
54100         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54101       };
54102     } catch (...) {
54103       {
54104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54105       };
54106     }
54107   }
54108
54109   jresult = result;
54110   return jresult;
54111 }
54112
54113
54114 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_GetConnectionCount(void * jarg1) {
54115   unsigned long jresult ;
54116   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54117   std::size_t result;
54118
54119   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54120   {
54121     try {
54122       result = Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
54123     } catch (std::out_of_range& e) {
54124       {
54125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54126       };
54127     } catch (std::exception& e) {
54128       {
54129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54130       };
54131     } catch (Dali::DaliException e) {
54132       {
54133         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54134       };
54135     } catch (...) {
54136       {
54137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54138       };
54139     }
54140   }
54141
54142   jresult = (unsigned long)result;
54143   return jresult;
54144 }
54145
54146
54147 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Connect(void * jarg1, void * jarg2) {
54148   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54149   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
54150
54151   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54152   arg2 = (void (*)(Dali::BaseHandle))jarg2;
54153   {
54154     try {
54155       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(arg1,arg2);
54156     } catch (std::out_of_range& e) {
54157       {
54158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54159       };
54160     } catch (std::exception& e) {
54161       {
54162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54163       };
54164     } catch (Dali::DaliException e) {
54165       {
54166         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54167       };
54168     } catch (...) {
54169       {
54170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54171       };
54172     }
54173   }
54174
54175 }
54176
54177
54178 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Disconnect(void * jarg1, void * jarg2) {
54179   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54180   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
54181
54182   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54183   arg2 = (void (*)(Dali::BaseHandle))jarg2;
54184   {
54185     try {
54186       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(arg1,arg2);
54187     } catch (std::out_of_range& e) {
54188       {
54189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54190       };
54191     } catch (std::exception& e) {
54192       {
54193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54194       };
54195     } catch (Dali::DaliException e) {
54196       {
54197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54198       };
54199     } catch (...) {
54200       {
54201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54202       };
54203     }
54204   }
54205
54206 }
54207
54208
54209 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Emit(void * jarg1, void * jarg2) {
54210   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54211   Dali::BaseHandle arg2 ;
54212   Dali::BaseHandle *argp2 ;
54213
54214   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54215   argp2 = (Dali::BaseHandle *)jarg2;
54216   if (!argp2) {
54217     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
54218     return ;
54219   }
54220   arg2 = *argp2;
54221   {
54222     try {
54223       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(arg1,arg2);
54224     } catch (std::out_of_range& e) {
54225       {
54226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54227       };
54228     } catch (std::exception& e) {
54229       {
54230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54231       };
54232     } catch (Dali::DaliException e) {
54233       {
54234         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54235       };
54236     } catch (...) {
54237       {
54238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54239       };
54240     }
54241   }
54242
54243 }
54244
54245
54246 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectCreatedSignal() {
54247   void * jresult ;
54248   Dali::Signal< void (Dali::BaseHandle) > *result = 0 ;
54249
54250   {
54251     try {
54252       result = (Dali::Signal< void (Dali::BaseHandle) > *)new Dali::Signal< void (Dali::BaseHandle) >();
54253     } catch (std::out_of_range& e) {
54254       {
54255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54256       };
54257     } catch (std::exception& e) {
54258       {
54259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54260       };
54261     } catch (Dali::DaliException e) {
54262       {
54263         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54264       };
54265     } catch (...) {
54266       {
54267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54268       };
54269     }
54270   }
54271
54272   jresult = (void *)result;
54273   return jresult;
54274 }
54275
54276
54277 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectCreatedSignal(void * jarg1) {
54278   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54279
54280   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54281   {
54282     try {
54283       delete arg1;
54284     } catch (std::out_of_range& e) {
54285       {
54286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54287       };
54288     } catch (std::exception& e) {
54289       {
54290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54291       };
54292     } catch (Dali::DaliException e) {
54293       {
54294         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54295       };
54296     } catch (...) {
54297       {
54298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54299       };
54300     }
54301   }
54302
54303 }
54304
54305
54306 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Empty(void * jarg1) {
54307   unsigned int jresult ;
54308   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54309   bool result;
54310
54311   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54312   {
54313     try {
54314       result = (bool)Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
54315     } catch (std::out_of_range& e) {
54316       {
54317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54318       };
54319     } catch (std::exception& e) {
54320       {
54321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54322       };
54323     } catch (Dali::DaliException e) {
54324       {
54325         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54326       };
54327     } catch (...) {
54328       {
54329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54330       };
54331     }
54332   }
54333
54334   jresult = result;
54335   return jresult;
54336 }
54337
54338
54339 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_GetConnectionCount(void * jarg1) {
54340   unsigned long jresult ;
54341   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54342   std::size_t result;
54343
54344   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54345   {
54346     try {
54347       result = Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
54348     } catch (std::out_of_range& e) {
54349       {
54350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54351       };
54352     } catch (std::exception& e) {
54353       {
54354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54355       };
54356     } catch (Dali::DaliException e) {
54357       {
54358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54359       };
54360     } catch (...) {
54361       {
54362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54363       };
54364     }
54365   }
54366
54367   jresult = (unsigned long)result;
54368   return jresult;
54369 }
54370
54371
54372 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Connect(void * jarg1, void * jarg2) {
54373   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54374   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
54375
54376   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54377   arg2 = (void (*)(Dali::RefObject const *))jarg2;
54378   {
54379     try {
54380       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Connect(arg1,arg2);
54381     } catch (std::out_of_range& e) {
54382       {
54383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54384       };
54385     } catch (std::exception& e) {
54386       {
54387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54388       };
54389     } catch (Dali::DaliException e) {
54390       {
54391         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54392       };
54393     } catch (...) {
54394       {
54395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54396       };
54397     }
54398   }
54399
54400 }
54401
54402
54403 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Disconnect(void * jarg1, void * jarg2) {
54404   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54405   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
54406
54407   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54408   arg2 = (void (*)(Dali::RefObject const *))jarg2;
54409   {
54410     try {
54411       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Disconnect(arg1,arg2);
54412     } catch (std::out_of_range& e) {
54413       {
54414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54415       };
54416     } catch (std::exception& e) {
54417       {
54418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54419       };
54420     } catch (Dali::DaliException e) {
54421       {
54422         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54423       };
54424     } catch (...) {
54425       {
54426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54427       };
54428     }
54429   }
54430
54431 }
54432
54433
54434 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Emit(void * jarg1, void * jarg2) {
54435   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54436   Dali::RefObject *arg2 = (Dali::RefObject *) 0 ;
54437
54438   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54439   arg2 = (Dali::RefObject *)jarg2;
54440   {
54441     try {
54442       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Emit(arg1,(Dali::RefObject const *)arg2);
54443     } catch (std::out_of_range& e) {
54444       {
54445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54446       };
54447     } catch (std::exception& e) {
54448       {
54449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54450       };
54451     } catch (Dali::DaliException e) {
54452       {
54453         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54454       };
54455     } catch (...) {
54456       {
54457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54458       };
54459     }
54460   }
54461
54462 }
54463
54464
54465 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectDestroyedSignal() {
54466   void * jresult ;
54467   Dali::Signal< void (Dali::RefObject const *) > *result = 0 ;
54468
54469   {
54470     try {
54471       result = (Dali::Signal< void (Dali::RefObject const *) > *)new Dali::Signal< void (Dali::RefObject const *) >();
54472     } catch (std::out_of_range& e) {
54473       {
54474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54475       };
54476     } catch (std::exception& e) {
54477       {
54478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54479       };
54480     } catch (Dali::DaliException e) {
54481       {
54482         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54483       };
54484     } catch (...) {
54485       {
54486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54487       };
54488     }
54489   }
54490
54491   jresult = (void *)result;
54492   return jresult;
54493 }
54494
54495
54496 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectDestroyedSignal(void * jarg1) {
54497   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54498
54499   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54500   {
54501     try {
54502       delete arg1;
54503     } catch (std::out_of_range& e) {
54504       {
54505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54506       };
54507     } catch (std::exception& e) {
54508       {
54509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54510       };
54511     } catch (Dali::DaliException e) {
54512       {
54513         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54514       };
54515     } catch (...) {
54516       {
54517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54518       };
54519     }
54520   }
54521
54522 }
54523
54524
54525 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Empty(void * jarg1) {
54526   unsigned int jresult ;
54527   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54528   bool result;
54529
54530   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54531   {
54532     try {
54533       result = (bool)Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
54534     } catch (std::out_of_range& e) {
54535       {
54536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54537       };
54538     } catch (std::exception& e) {
54539       {
54540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54541       };
54542     } catch (Dali::DaliException e) {
54543       {
54544         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54545       };
54546     } catch (...) {
54547       {
54548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54549       };
54550     }
54551   }
54552
54553   jresult = result;
54554   return jresult;
54555 }
54556
54557
54558 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_GetConnectionCount(void * jarg1) {
54559   unsigned long jresult ;
54560   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54561   std::size_t result;
54562
54563   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54564   {
54565     try {
54566       result = Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
54567     } catch (std::out_of_range& e) {
54568       {
54569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54570       };
54571     } catch (std::exception& e) {
54572       {
54573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54574       };
54575     } catch (Dali::DaliException e) {
54576       {
54577         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54578       };
54579     } catch (...) {
54580       {
54581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54582       };
54583     }
54584   }
54585
54586   jresult = (unsigned long)result;
54587   return jresult;
54588 }
54589
54590
54591 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Connect(void * jarg1, void * jarg2) {
54592   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54593   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
54594
54595   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54596   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
54597   {
54598     try {
54599       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(arg1,arg2);
54600     } catch (std::out_of_range& e) {
54601       {
54602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54603       };
54604     } catch (std::exception& e) {
54605       {
54606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54607       };
54608     } catch (Dali::DaliException e) {
54609       {
54610         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54611       };
54612     } catch (...) {
54613       {
54614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54615       };
54616     }
54617   }
54618
54619 }
54620
54621
54622 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Disconnect(void * jarg1, void * jarg2) {
54623   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54624   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
54625
54626   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54627   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
54628   {
54629     try {
54630       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(arg1,arg2);
54631     } catch (std::out_of_range& e) {
54632       {
54633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54634       };
54635     } catch (std::exception& e) {
54636       {
54637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54638       };
54639     } catch (Dali::DaliException e) {
54640       {
54641         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54642       };
54643     } catch (...) {
54644       {
54645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54646       };
54647     }
54648   }
54649
54650 }
54651
54652
54653 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Emit(void * jarg1, void * jarg2) {
54654   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54655   Dali::PropertyNotification *arg2 = 0 ;
54656
54657   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54658   arg2 = (Dali::PropertyNotification *)jarg2;
54659   if (!arg2) {
54660     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification & type is null", 0);
54661     return ;
54662   }
54663   {
54664     try {
54665       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(arg1,*arg2);
54666     } catch (std::out_of_range& e) {
54667       {
54668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54669       };
54670     } catch (std::exception& e) {
54671       {
54672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54673       };
54674     } catch (Dali::DaliException e) {
54675       {
54676         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54677       };
54678     } catch (...) {
54679       {
54680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54681       };
54682     }
54683   }
54684
54685 }
54686
54687
54688 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotifySignal() {
54689   void * jresult ;
54690   Dali::Signal< void (Dali::PropertyNotification &) > *result = 0 ;
54691
54692   {
54693     try {
54694       result = (Dali::Signal< void (Dali::PropertyNotification &) > *)new Dali::Signal< void (Dali::PropertyNotification &) >();
54695     } catch (std::out_of_range& e) {
54696       {
54697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54698       };
54699     } catch (std::exception& e) {
54700       {
54701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54702       };
54703     } catch (Dali::DaliException e) {
54704       {
54705         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54706       };
54707     } catch (...) {
54708       {
54709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54710       };
54711     }
54712   }
54713
54714   jresult = (void *)result;
54715   return jresult;
54716 }
54717
54718
54719 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotifySignal(void * jarg1) {
54720   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54721
54722   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54723   {
54724     try {
54725       delete arg1;
54726     } catch (std::out_of_range& e) {
54727       {
54728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54729       };
54730     } catch (std::exception& e) {
54731       {
54732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54733       };
54734     } catch (Dali::DaliException e) {
54735       {
54736         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54737       };
54738     } catch (...) {
54739       {
54740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54741       };
54742     }
54743   }
54744
54745 }
54746
54747
54748 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ImageSignal_Empty(void * jarg1) {
54749   unsigned int jresult ;
54750   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54751   bool result;
54752
54753   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54754   {
54755     try {
54756       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Empty((Dali::Signal< void (Dali::Image) > const *)arg1);
54757     } catch (std::out_of_range& e) {
54758       {
54759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54760       };
54761     } catch (std::exception& e) {
54762       {
54763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54764       };
54765     } catch (Dali::DaliException e) {
54766       {
54767         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54768       };
54769     } catch (...) {
54770       {
54771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54772       };
54773     }
54774   }
54775
54776   jresult = result;
54777   return jresult;
54778 }
54779
54780
54781 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ImageSignal_GetConnectionCount(void * jarg1) {
54782   unsigned long jresult ;
54783   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54784   std::size_t result;
54785
54786   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54787   {
54788     try {
54789       result = Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Image) > const *)arg1);
54790     } catch (std::out_of_range& e) {
54791       {
54792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54793       };
54794     } catch (std::exception& e) {
54795       {
54796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54797       };
54798     } catch (Dali::DaliException e) {
54799       {
54800         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54801       };
54802     } catch (...) {
54803       {
54804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54805       };
54806     }
54807   }
54808
54809   jresult = (unsigned long)result;
54810   return jresult;
54811 }
54812
54813
54814 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Connect(void * jarg1, void * jarg2) {
54815   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54816   void (*arg2)(Dali::Image) = (void (*)(Dali::Image)) 0 ;
54817
54818   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54819   arg2 = (void (*)(Dali::Image))jarg2;
54820   {
54821     try {
54822       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Connect(arg1,arg2);
54823     } catch (std::out_of_range& e) {
54824       {
54825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54826       };
54827     } catch (std::exception& e) {
54828       {
54829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54830       };
54831     } catch (Dali::DaliException e) {
54832       {
54833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54834       };
54835     } catch (...) {
54836       {
54837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54838       };
54839     }
54840   }
54841
54842 }
54843
54844
54845 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Disconnect(void * jarg1, void * jarg2) {
54846   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54847   void (*arg2)(Dali::Image) = (void (*)(Dali::Image)) 0 ;
54848
54849   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54850   arg2 = (void (*)(Dali::Image))jarg2;
54851   {
54852     try {
54853       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Disconnect(arg1,arg2);
54854     } catch (std::out_of_range& e) {
54855       {
54856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54857       };
54858     } catch (std::exception& e) {
54859       {
54860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54861       };
54862     } catch (Dali::DaliException e) {
54863       {
54864         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54865       };
54866     } catch (...) {
54867       {
54868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54869       };
54870     }
54871   }
54872
54873 }
54874
54875
54876 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Emit(void * jarg1, void * jarg2) {
54877   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54878   Dali::Image arg2 ;
54879   Dali::Image *argp2 ;
54880
54881   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54882   argp2 = (Dali::Image *)jarg2;
54883   if (!argp2) {
54884     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
54885     return ;
54886   }
54887   arg2 = *argp2;
54888   {
54889     try {
54890       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Emit(arg1,arg2);
54891     } catch (std::out_of_range& e) {
54892       {
54893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54894       };
54895     } catch (std::exception& e) {
54896       {
54897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54898       };
54899     } catch (Dali::DaliException e) {
54900       {
54901         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54902       };
54903     } catch (...) {
54904       {
54905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54906       };
54907     }
54908   }
54909
54910 }
54911
54912
54913 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageSignal() {
54914   void * jresult ;
54915   Dali::Signal< void (Dali::Image) > *result = 0 ;
54916
54917   {
54918     try {
54919       result = (Dali::Signal< void (Dali::Image) > *)new Dali::Signal< void (Dali::Image) >();
54920     } catch (std::out_of_range& e) {
54921       {
54922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54923       };
54924     } catch (std::exception& e) {
54925       {
54926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54927       };
54928     } catch (Dali::DaliException e) {
54929       {
54930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54931       };
54932     } catch (...) {
54933       {
54934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54935       };
54936     }
54937   }
54938
54939   jresult = (void *)result;
54940   return jresult;
54941 }
54942
54943
54944 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageSignal(void * jarg1) {
54945   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54946
54947   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54948   {
54949     try {
54950       delete arg1;
54951     } catch (std::out_of_range& e) {
54952       {
54953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54954       };
54955     } catch (std::exception& e) {
54956       {
54957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54958       };
54959     } catch (Dali::DaliException e) {
54960       {
54961         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54962       };
54963     } catch (...) {
54964       {
54965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54966       };
54967     }
54968   }
54969
54970 }
54971
54972
54973 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskSignal() {
54974   void * jresult ;
54975   Dali::Signal< void (Dali::RenderTask &) > *result = 0 ;
54976
54977   {
54978     try {
54979       result = (Dali::Signal< void (Dali::RenderTask &) > *)new Dali::Signal< void (Dali::RenderTask &) >();
54980     } catch (std::out_of_range& e) {
54981       {
54982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54983       };
54984     } catch (std::exception& e) {
54985       {
54986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54987       };
54988     } catch (Dali::DaliException e) {
54989       {
54990         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54991       };
54992     } catch (...) {
54993       {
54994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54995       };
54996     }
54997   }
54998
54999   jresult = (void *)result;
55000   return jresult;
55001 }
55002
55003
55004 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskSignal(void * jarg1) {
55005   Dali::Signal< void (Dali::RenderTask &) > *arg1 = (Dali::Signal< void (Dali::RenderTask &) > *) 0 ;
55006
55007   arg1 = (Dali::Signal< void (Dali::RenderTask &) > *)jarg1;
55008   {
55009     try {
55010       delete arg1;
55011     } catch (std::out_of_range& e) {
55012       {
55013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55014       };
55015     } catch (std::exception& e) {
55016       {
55017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55018       };
55019     } catch (Dali::DaliException e) {
55020       {
55021         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55022       };
55023     } catch (...) {
55024       {
55025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55026       };
55027     }
55028   }
55029
55030 }
55031
55032
55033 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Empty(void * jarg1) {
55034   unsigned int jresult ;
55035   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55036   bool result;
55037
55038   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55039   {
55040     try {
55041       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);
55042     } catch (std::out_of_range& e) {
55043       {
55044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55045       };
55046     } catch (std::exception& e) {
55047       {
55048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55049       };
55050     } catch (Dali::DaliException e) {
55051       {
55052         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55053       };
55054     } catch (...) {
55055       {
55056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55057       };
55058     }
55059   }
55060
55061   jresult = result;
55062   return jresult;
55063 }
55064
55065
55066 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_GetConnectionCount(void * jarg1) {
55067   unsigned long jresult ;
55068   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55069   std::size_t result;
55070
55071   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55072   {
55073     try {
55074       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);
55075     } catch (std::out_of_range& e) {
55076       {
55077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55078       };
55079     } catch (std::exception& e) {
55080       {
55081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55082       };
55083     } catch (Dali::DaliException e) {
55084       {
55085         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55086       };
55087     } catch (...) {
55088       {
55089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55090       };
55091     }
55092   }
55093
55094   jresult = (unsigned long)result;
55095   return jresult;
55096 }
55097
55098
55099 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
55100   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55101   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
55102
55103   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55104   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
55105   {
55106     try {
55107       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
55108     } catch (std::out_of_range& e) {
55109       {
55110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55111       };
55112     } catch (std::exception& e) {
55113       {
55114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55115       };
55116     } catch (Dali::DaliException e) {
55117       {
55118         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55119       };
55120     } catch (...) {
55121       {
55122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55123       };
55124     }
55125   }
55126
55127 }
55128
55129
55130 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
55131   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55132   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
55133
55134   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55135   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
55136   {
55137     try {
55138       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
55139     } catch (std::out_of_range& e) {
55140       {
55141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55142       };
55143     } catch (std::exception& e) {
55144       {
55145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55146       };
55147     } catch (Dali::DaliException e) {
55148       {
55149         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55150       };
55151     } catch (...) {
55152       {
55153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55154       };
55155     }
55156   }
55157
55158 }
55159
55160
55161 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
55162   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55163   Dali::Actor arg2 ;
55164   Dali::LongPressGesture *arg3 = 0 ;
55165   Dali::Actor *argp2 ;
55166
55167   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55168   argp2 = (Dali::Actor *)jarg2;
55169   if (!argp2) {
55170     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55171     return ;
55172   }
55173   arg2 = *argp2;
55174   arg3 = (Dali::LongPressGesture *)jarg3;
55175   if (!arg3) {
55176     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
55177     return ;
55178   }
55179   {
55180     try {
55181       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::LongPressGesture const &)*arg3);
55182     } catch (std::out_of_range& e) {
55183       {
55184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55185       };
55186     } catch (std::exception& e) {
55187       {
55188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55189       };
55190     } catch (Dali::DaliException e) {
55191       {
55192         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55193       };
55194     } catch (...) {
55195       {
55196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55197       };
55198     }
55199   }
55200
55201 }
55202
55203
55204 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetectedSignal() {
55205   void * jresult ;
55206   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *result = 0 ;
55207
55208   {
55209     try {
55210       result = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) >();
55211     } catch (std::out_of_range& e) {
55212       {
55213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55214       };
55215     } catch (std::exception& e) {
55216       {
55217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55218       };
55219     } catch (Dali::DaliException e) {
55220       {
55221         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55222       };
55223     } catch (...) {
55224       {
55225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55226       };
55227     }
55228   }
55229
55230   jresult = (void *)result;
55231   return jresult;
55232 }
55233
55234
55235 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetectedSignal(void * jarg1) {
55236   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55237
55238   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55239   {
55240     try {
55241       delete arg1;
55242     } catch (std::out_of_range& e) {
55243       {
55244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55245       };
55246     } catch (std::exception& e) {
55247       {
55248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55249       };
55250     } catch (Dali::DaliException e) {
55251       {
55252         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55253       };
55254     } catch (...) {
55255       {
55256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55257       };
55258     }
55259   }
55260
55261 }
55262
55263
55264 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Empty(void * jarg1) {
55265   unsigned int jresult ;
55266   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55267   bool result;
55268
55269   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55270   {
55271     try {
55272       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);
55273     } catch (std::out_of_range& e) {
55274       {
55275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55276       };
55277     } catch (std::exception& e) {
55278       {
55279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55280       };
55281     } catch (Dali::DaliException e) {
55282       {
55283         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55284       };
55285     } catch (...) {
55286       {
55287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55288       };
55289     }
55290   }
55291
55292   jresult = result;
55293   return jresult;
55294 }
55295
55296
55297 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_GetConnectionCount(void * jarg1) {
55298   unsigned long jresult ;
55299   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55300   std::size_t result;
55301
55302   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55303   {
55304     try {
55305       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);
55306     } catch (std::out_of_range& e) {
55307       {
55308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55309       };
55310     } catch (std::exception& e) {
55311       {
55312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55313       };
55314     } catch (Dali::DaliException e) {
55315       {
55316         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55317       };
55318     } catch (...) {
55319       {
55320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55321       };
55322     }
55323   }
55324
55325   jresult = (unsigned long)result;
55326   return jresult;
55327 }
55328
55329
55330 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Connect(void * jarg1, void * jarg2) {
55331   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55332   bool (*arg2)(Dali::Actor,Dali::TouchData const &) = (bool (*)(Dali::Actor,Dali::TouchData const &)) 0 ;
55333
55334   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55335   arg2 = (bool (*)(Dali::Actor,Dali::TouchData const &))jarg2;
55336   {
55337     try {
55338       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Connect(arg1,arg2);
55339     } catch (std::out_of_range& e) {
55340       {
55341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55342       };
55343     } catch (std::exception& e) {
55344       {
55345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55346       };
55347     } catch (Dali::DaliException e) {
55348       {
55349         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55350       };
55351     } catch (...) {
55352       {
55353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55354       };
55355     }
55356   }
55357
55358 }
55359
55360
55361 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Disconnect(void * jarg1, void * jarg2) {
55362   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55363   bool (*arg2)(Dali::Actor,Dali::TouchData const &) = (bool (*)(Dali::Actor,Dali::TouchData const &)) 0 ;
55364
55365   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55366   arg2 = (bool (*)(Dali::Actor,Dali::TouchData const &))jarg2;
55367   {
55368     try {
55369       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
55370     } catch (std::out_of_range& e) {
55371       {
55372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55373       };
55374     } catch (std::exception& e) {
55375       {
55376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55377       };
55378     } catch (Dali::DaliException e) {
55379       {
55380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55381       };
55382     } catch (...) {
55383       {
55384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55385       };
55386     }
55387   }
55388
55389 }
55390
55391
55392 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
55393   unsigned int jresult ;
55394   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55395   Dali::Actor arg2 ;
55396   Dali::TouchData *arg3 = 0 ;
55397   Dali::Actor *argp2 ;
55398   bool result;
55399
55400   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55401   argp2 = (Dali::Actor *)jarg2;
55402   if (!argp2) {
55403     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55404     return 0;
55405   }
55406   arg2 = *argp2;
55407   arg3 = (Dali::TouchData *)jarg3;
55408   if (!arg3) {
55409     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
55410     return 0;
55411   }
55412   {
55413     try {
55414       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TouchData const &)*arg3);
55415     } catch (std::out_of_range& e) {
55416       {
55417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55418       };
55419     } catch (std::exception& e) {
55420       {
55421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55422       };
55423     } catch (Dali::DaliException e) {
55424       {
55425         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55426       };
55427     } catch (...) {
55428       {
55429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55430       };
55431     }
55432   }
55433
55434   jresult = result;
55435   return jresult;
55436 }
55437
55438
55439 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorTouchDataSignal() {
55440   void * jresult ;
55441   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *result = 0 ;
55442
55443   {
55444     try {
55445       result = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) >();
55446     } catch (std::out_of_range& e) {
55447       {
55448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55449       };
55450     } catch (std::exception& e) {
55451       {
55452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55453       };
55454     } catch (Dali::DaliException e) {
55455       {
55456         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55457       };
55458     } catch (...) {
55459       {
55460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55461       };
55462     }
55463   }
55464
55465   jresult = (void *)result;
55466   return jresult;
55467 }
55468
55469
55470 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorTouchDataSignal(void * jarg1) {
55471   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55472
55473   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55474   {
55475     try {
55476       delete arg1;
55477     } catch (std::out_of_range& e) {
55478       {
55479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55480       };
55481     } catch (std::exception& e) {
55482       {
55483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55484       };
55485     } catch (Dali::DaliException e) {
55486       {
55487         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55488       };
55489     } catch (...) {
55490       {
55491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55492       };
55493     }
55494   }
55495
55496 }
55497
55498
55499 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Empty(void * jarg1) {
55500   unsigned int jresult ;
55501   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55502   bool result;
55503
55504   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55505   {
55506     try {
55507       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);
55508     } catch (std::out_of_range& e) {
55509       {
55510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55511       };
55512     } catch (std::exception& e) {
55513       {
55514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55515       };
55516     } catch (Dali::DaliException e) {
55517       {
55518         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55519       };
55520     } catch (...) {
55521       {
55522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55523       };
55524     }
55525   }
55526
55527   jresult = result;
55528   return jresult;
55529 }
55530
55531
55532 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorHoverSignal_GetConnectionCount(void * jarg1) {
55533   unsigned long jresult ;
55534   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55535   std::size_t result;
55536
55537   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55538   {
55539     try {
55540       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);
55541     } catch (std::out_of_range& e) {
55542       {
55543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55544       };
55545     } catch (std::exception& e) {
55546       {
55547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55548       };
55549     } catch (Dali::DaliException e) {
55550       {
55551         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55552       };
55553     } catch (...) {
55554       {
55555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55556       };
55557     }
55558   }
55559
55560   jresult = (unsigned long)result;
55561   return jresult;
55562 }
55563
55564
55565 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Connect(void * jarg1, void * jarg2) {
55566   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55567   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
55568
55569   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55570   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
55571   {
55572     try {
55573       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
55574     } catch (std::out_of_range& e) {
55575       {
55576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55577       };
55578     } catch (std::exception& e) {
55579       {
55580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55581       };
55582     } catch (Dali::DaliException e) {
55583       {
55584         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55585       };
55586     } catch (...) {
55587       {
55588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55589       };
55590     }
55591   }
55592
55593 }
55594
55595
55596 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Disconnect(void * jarg1, void * jarg2) {
55597   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55598   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
55599
55600   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55601   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
55602   {
55603     try {
55604       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
55605     } catch (std::out_of_range& e) {
55606       {
55607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55608       };
55609     } catch (std::exception& e) {
55610       {
55611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55612       };
55613     } catch (Dali::DaliException e) {
55614       {
55615         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55616       };
55617     } catch (...) {
55618       {
55619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55620       };
55621     }
55622   }
55623
55624 }
55625
55626
55627 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
55628   unsigned int jresult ;
55629   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55630   Dali::Actor arg2 ;
55631   Dali::HoverEvent *arg3 = 0 ;
55632   Dali::Actor *argp2 ;
55633   bool result;
55634
55635   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55636   argp2 = (Dali::Actor *)jarg2;
55637   if (!argp2) {
55638     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55639     return 0;
55640   }
55641   arg2 = *argp2;
55642   arg3 = (Dali::HoverEvent *)jarg3;
55643   if (!arg3) {
55644     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
55645     return 0;
55646   }
55647   {
55648     try {
55649       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::HoverEvent const &)*arg3);
55650     } catch (std::out_of_range& e) {
55651       {
55652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55653       };
55654     } catch (std::exception& e) {
55655       {
55656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55657       };
55658     } catch (Dali::DaliException e) {
55659       {
55660         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55661       };
55662     } catch (...) {
55663       {
55664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55665       };
55666     }
55667   }
55668
55669   jresult = result;
55670   return jresult;
55671 }
55672
55673
55674 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorHoverSignal() {
55675   void * jresult ;
55676   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *result = 0 ;
55677
55678   {
55679     try {
55680       result = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) >();
55681     } catch (std::out_of_range& e) {
55682       {
55683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55684       };
55685     } catch (std::exception& e) {
55686       {
55687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55688       };
55689     } catch (Dali::DaliException e) {
55690       {
55691         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55692       };
55693     } catch (...) {
55694       {
55695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55696       };
55697     }
55698   }
55699
55700   jresult = (void *)result;
55701   return jresult;
55702 }
55703
55704
55705 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorHoverSignal(void * jarg1) {
55706   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55707
55708   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55709   {
55710     try {
55711       delete arg1;
55712     } catch (std::out_of_range& e) {
55713       {
55714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55715       };
55716     } catch (std::exception& e) {
55717       {
55718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55719       };
55720     } catch (Dali::DaliException e) {
55721       {
55722         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55723       };
55724     } catch (...) {
55725       {
55726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55727       };
55728     }
55729   }
55730
55731 }
55732
55733
55734 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Empty(void * jarg1) {
55735   unsigned int jresult ;
55736   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55737   bool result;
55738
55739   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55740   {
55741     try {
55742       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);
55743     } catch (std::out_of_range& e) {
55744       {
55745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55746       };
55747     } catch (std::exception& e) {
55748       {
55749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55750       };
55751     } catch (Dali::DaliException e) {
55752       {
55753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55754       };
55755     } catch (...) {
55756       {
55757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55758       };
55759     }
55760   }
55761
55762   jresult = result;
55763   return jresult;
55764 }
55765
55766
55767 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorWheelSignal_GetConnectionCount(void * jarg1) {
55768   unsigned long jresult ;
55769   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55770   std::size_t result;
55771
55772   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55773   {
55774     try {
55775       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);
55776     } catch (std::out_of_range& e) {
55777       {
55778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55779       };
55780     } catch (std::exception& e) {
55781       {
55782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55783       };
55784     } catch (Dali::DaliException e) {
55785       {
55786         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55787       };
55788     } catch (...) {
55789       {
55790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55791       };
55792     }
55793   }
55794
55795   jresult = (unsigned long)result;
55796   return jresult;
55797 }
55798
55799
55800 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Connect(void * jarg1, void * jarg2) {
55801   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55802   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
55803
55804   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55805   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
55806   {
55807     try {
55808       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
55809     } catch (std::out_of_range& e) {
55810       {
55811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55812       };
55813     } catch (std::exception& e) {
55814       {
55815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55816       };
55817     } catch (Dali::DaliException e) {
55818       {
55819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55820       };
55821     } catch (...) {
55822       {
55823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55824       };
55825     }
55826   }
55827
55828 }
55829
55830
55831 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Disconnect(void * jarg1, void * jarg2) {
55832   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55833   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
55834
55835   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55836   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
55837   {
55838     try {
55839       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
55840     } catch (std::out_of_range& e) {
55841       {
55842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55843       };
55844     } catch (std::exception& e) {
55845       {
55846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55847       };
55848     } catch (Dali::DaliException e) {
55849       {
55850         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55851       };
55852     } catch (...) {
55853       {
55854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55855       };
55856     }
55857   }
55858
55859 }
55860
55861
55862 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
55863   unsigned int jresult ;
55864   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55865   Dali::Actor arg2 ;
55866   Dali::WheelEvent *arg3 = 0 ;
55867   Dali::Actor *argp2 ;
55868   bool result;
55869
55870   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55871   argp2 = (Dali::Actor *)jarg2;
55872   if (!argp2) {
55873     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55874     return 0;
55875   }
55876   arg2 = *argp2;
55877   arg3 = (Dali::WheelEvent *)jarg3;
55878   if (!arg3) {
55879     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
55880     return 0;
55881   }
55882   {
55883     try {
55884       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::WheelEvent const &)*arg3);
55885     } catch (std::out_of_range& e) {
55886       {
55887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55888       };
55889     } catch (std::exception& e) {
55890       {
55891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55892       };
55893     } catch (Dali::DaliException e) {
55894       {
55895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55896       };
55897     } catch (...) {
55898       {
55899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55900       };
55901     }
55902   }
55903
55904   jresult = result;
55905   return jresult;
55906 }
55907
55908
55909 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorWheelSignal() {
55910   void * jresult ;
55911   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *result = 0 ;
55912
55913   {
55914     try {
55915       result = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) >();
55916     } catch (std::out_of_range& e) {
55917       {
55918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55919       };
55920     } catch (std::exception& e) {
55921       {
55922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55923       };
55924     } catch (Dali::DaliException e) {
55925       {
55926         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55927       };
55928     } catch (...) {
55929       {
55930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55931       };
55932     }
55933   }
55934
55935   jresult = (void *)result;
55936   return jresult;
55937 }
55938
55939
55940 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorWheelSignal(void * jarg1) {
55941   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55942
55943   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55944   {
55945     try {
55946       delete arg1;
55947     } catch (std::out_of_range& e) {
55948       {
55949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55950       };
55951     } catch (std::exception& e) {
55952       {
55953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55954       };
55955     } catch (Dali::DaliException e) {
55956       {
55957         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55958       };
55959     } catch (...) {
55960       {
55961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55962       };
55963     }
55964   }
55965
55966 }
55967
55968
55969 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorSignal_Empty(void * jarg1) {
55970   unsigned int jresult ;
55971   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
55972   bool result;
55973
55974   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
55975   {
55976     try {
55977       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor) > const *)arg1);
55978     } catch (std::out_of_range& e) {
55979       {
55980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55981       };
55982     } catch (std::exception& e) {
55983       {
55984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55985       };
55986     } catch (Dali::DaliException e) {
55987       {
55988         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55989       };
55990     } catch (...) {
55991       {
55992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55993       };
55994     }
55995   }
55996
55997   jresult = result;
55998   return jresult;
55999 }
56000
56001
56002 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorSignal_GetConnectionCount(void * jarg1) {
56003   unsigned long jresult ;
56004   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56005   std::size_t result;
56006
56007   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56008   {
56009     try {
56010       result = Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor) > const *)arg1);
56011     } catch (std::out_of_range& e) {
56012       {
56013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56014       };
56015     } catch (std::exception& e) {
56016       {
56017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56018       };
56019     } catch (Dali::DaliException e) {
56020       {
56021         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56022       };
56023     } catch (...) {
56024       {
56025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56026       };
56027     }
56028   }
56029
56030   jresult = (unsigned long)result;
56031   return jresult;
56032 }
56033
56034
56035 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Connect(void * jarg1, void * jarg2) {
56036   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56037   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
56038
56039   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56040   arg2 = (void (*)(Dali::Actor))jarg2;
56041   {
56042     try {
56043       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(arg1,arg2);
56044     } catch (std::out_of_range& e) {
56045       {
56046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56047       };
56048     } catch (std::exception& e) {
56049       {
56050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56051       };
56052     } catch (Dali::DaliException e) {
56053       {
56054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56055       };
56056     } catch (...) {
56057       {
56058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56059       };
56060     }
56061   }
56062
56063 }
56064
56065
56066 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Disconnect(void * jarg1, void * jarg2) {
56067   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56068   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
56069
56070   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56071   arg2 = (void (*)(Dali::Actor))jarg2;
56072   {
56073     try {
56074       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
56075     } catch (std::out_of_range& e) {
56076       {
56077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56078       };
56079     } catch (std::exception& e) {
56080       {
56081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56082       };
56083     } catch (Dali::DaliException e) {
56084       {
56085         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56086       };
56087     } catch (...) {
56088       {
56089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56090       };
56091     }
56092   }
56093
56094 }
56095
56096
56097 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Emit(void * jarg1, void * jarg2) {
56098   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56099   Dali::Actor arg2 ;
56100   Dali::Actor *argp2 ;
56101
56102   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56103   argp2 = (Dali::Actor *)jarg2;
56104   if (!argp2) {
56105     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
56106     return ;
56107   }
56108   arg2 = *argp2;
56109   {
56110     try {
56111       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(arg1,arg2);
56112     } catch (std::out_of_range& e) {
56113       {
56114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56115       };
56116     } catch (std::exception& e) {
56117       {
56118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56119       };
56120     } catch (Dali::DaliException e) {
56121       {
56122         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56123       };
56124     } catch (...) {
56125       {
56126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56127       };
56128     }
56129   }
56130
56131 }
56132
56133
56134 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorSignal() {
56135   void * jresult ;
56136   Dali::Signal< void (Dali::Actor) > *result = 0 ;
56137
56138   {
56139     try {
56140       result = (Dali::Signal< void (Dali::Actor) > *)new Dali::Signal< void (Dali::Actor) >();
56141     } catch (std::out_of_range& e) {
56142       {
56143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56144       };
56145     } catch (std::exception& e) {
56146       {
56147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56148       };
56149     } catch (Dali::DaliException e) {
56150       {
56151         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56152       };
56153     } catch (...) {
56154       {
56155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56156       };
56157     }
56158   }
56159
56160   jresult = (void *)result;
56161   return jresult;
56162 }
56163
56164
56165 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorSignal(void * jarg1) {
56166   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56167
56168   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56169   {
56170     try {
56171       delete arg1;
56172     } catch (std::out_of_range& e) {
56173       {
56174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56175       };
56176     } catch (std::exception& e) {
56177       {
56178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56179       };
56180     } catch (Dali::DaliException e) {
56181       {
56182         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56183       };
56184     } catch (...) {
56185       {
56186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56187       };
56188     }
56189   }
56190
56191 }
56192
56193
56194 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyEventSignal_Empty(void * jarg1) {
56195   unsigned int jresult ;
56196   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56197   bool result;
56198
56199   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56200   {
56201     try {
56202       result = (bool)Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
56203     } catch (std::out_of_range& e) {
56204       {
56205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56206       };
56207     } catch (std::exception& e) {
56208       {
56209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56210       };
56211     } catch (Dali::DaliException e) {
56212       {
56213         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56214       };
56215     } catch (...) {
56216       {
56217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56218       };
56219     }
56220   }
56221
56222   jresult = result;
56223   return jresult;
56224 }
56225
56226
56227 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyEventSignal_GetConnectionCount(void * jarg1) {
56228   unsigned long jresult ;
56229   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56230   std::size_t result;
56231
56232   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56233   {
56234     try {
56235       result = Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
56236     } catch (std::out_of_range& e) {
56237       {
56238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56239       };
56240     } catch (std::exception& e) {
56241       {
56242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56243       };
56244     } catch (Dali::DaliException e) {
56245       {
56246         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56247       };
56248     } catch (...) {
56249       {
56250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56251       };
56252     }
56253   }
56254
56255   jresult = (unsigned long)result;
56256   return jresult;
56257 }
56258
56259
56260 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Connect(void * jarg1, void * jarg2) {
56261   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56262   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
56263
56264   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56265   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
56266   {
56267     try {
56268       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
56269     } catch (std::out_of_range& e) {
56270       {
56271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56272       };
56273     } catch (std::exception& e) {
56274       {
56275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56276       };
56277     } catch (Dali::DaliException e) {
56278       {
56279         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56280       };
56281     } catch (...) {
56282       {
56283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56284       };
56285     }
56286   }
56287
56288 }
56289
56290
56291 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Disconnect(void * jarg1, void * jarg2) {
56292   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56293   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
56294
56295   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56296   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
56297   {
56298     try {
56299       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
56300     } catch (std::out_of_range& e) {
56301       {
56302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56303       };
56304     } catch (std::exception& e) {
56305       {
56306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56307       };
56308     } catch (Dali::DaliException e) {
56309       {
56310         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56311       };
56312     } catch (...) {
56313       {
56314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56315       };
56316     }
56317   }
56318
56319 }
56320
56321
56322 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Emit(void * jarg1, void * jarg2) {
56323   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56324   Dali::KeyEvent *arg2 = 0 ;
56325
56326   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56327   arg2 = (Dali::KeyEvent *)jarg2;
56328   if (!arg2) {
56329     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
56330     return ;
56331   }
56332   {
56333     try {
56334       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::KeyEvent const &)*arg2);
56335     } catch (std::out_of_range& e) {
56336       {
56337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56338       };
56339     } catch (std::exception& e) {
56340       {
56341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56342       };
56343     } catch (Dali::DaliException e) {
56344       {
56345         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56346       };
56347     } catch (...) {
56348       {
56349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56350       };
56351     }
56352   }
56353
56354 }
56355
56356
56357 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyEventSignal() {
56358   void * jresult ;
56359   Dali::Signal< void (Dali::KeyEvent const &) > *result = 0 ;
56360
56361   {
56362     try {
56363       result = (Dali::Signal< void (Dali::KeyEvent const &) > *)new Dali::Signal< void (Dali::KeyEvent const &) >();
56364     } catch (std::out_of_range& e) {
56365       {
56366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56367       };
56368     } catch (std::exception& e) {
56369       {
56370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56371       };
56372     } catch (Dali::DaliException e) {
56373       {
56374         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56375       };
56376     } catch (...) {
56377       {
56378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56379       };
56380     }
56381   }
56382
56383   jresult = (void *)result;
56384   return jresult;
56385 }
56386
56387
56388 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyEventSignal(void * jarg1) {
56389   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56390
56391   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56392   {
56393     try {
56394       delete arg1;
56395     } catch (std::out_of_range& e) {
56396       {
56397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56398       };
56399     } catch (std::exception& e) {
56400       {
56401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56402       };
56403     } catch (Dali::DaliException e) {
56404       {
56405         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56406       };
56407     } catch (...) {
56408       {
56409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56410       };
56411     }
56412   }
56413
56414 }
56415
56416
56417 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TouchSignal_Empty(void * jarg1) {
56418   unsigned int jresult ;
56419   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56420   bool result;
56421
56422   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56423   {
56424     try {
56425       result = (bool)Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::TouchData const &) > const *)arg1);
56426     } catch (std::out_of_range& e) {
56427       {
56428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56429       };
56430     } catch (std::exception& e) {
56431       {
56432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56433       };
56434     } catch (Dali::DaliException e) {
56435       {
56436         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56437       };
56438     } catch (...) {
56439       {
56440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56441       };
56442     }
56443   }
56444
56445   jresult = result;
56446   return jresult;
56447 }
56448
56449
56450 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchSignal_GetConnectionCount(void * jarg1) {
56451   unsigned long jresult ;
56452   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56453   std::size_t result;
56454
56455   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56456   {
56457     try {
56458       result = Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::TouchData const &) > const *)arg1);
56459     } catch (std::out_of_range& e) {
56460       {
56461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56462       };
56463     } catch (std::exception& e) {
56464       {
56465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56466       };
56467     } catch (Dali::DaliException e) {
56468       {
56469         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56470       };
56471     } catch (...) {
56472       {
56473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56474       };
56475     }
56476   }
56477
56478   jresult = (unsigned long)result;
56479   return jresult;
56480 }
56481
56482
56483 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Connect(void * jarg1, void * jarg2) {
56484   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56485   void (*arg2)(Dali::TouchData const &) = (void (*)(Dali::TouchData const &)) 0 ;
56486
56487   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56488   arg2 = (void (*)(Dali::TouchData const &))jarg2;
56489   {
56490     try {
56491       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Connect(arg1,arg2);
56492     } catch (std::out_of_range& e) {
56493       {
56494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56495       };
56496     } catch (std::exception& e) {
56497       {
56498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56499       };
56500     } catch (Dali::DaliException e) {
56501       {
56502         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56503       };
56504     } catch (...) {
56505       {
56506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56507       };
56508     }
56509   }
56510
56511 }
56512
56513
56514 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Disconnect(void * jarg1, void * jarg2) {
56515   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56516   void (*arg2)(Dali::TouchData const &) = (void (*)(Dali::TouchData const &)) 0 ;
56517
56518   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56519   arg2 = (void (*)(Dali::TouchData const &))jarg2;
56520   {
56521     try {
56522       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
56523     } catch (std::out_of_range& e) {
56524       {
56525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56526       };
56527     } catch (std::exception& e) {
56528       {
56529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56530       };
56531     } catch (Dali::DaliException e) {
56532       {
56533         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56534       };
56535     } catch (...) {
56536       {
56537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56538       };
56539     }
56540   }
56541
56542 }
56543
56544
56545 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Emit(void * jarg1, void * jarg2) {
56546   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56547   Dali::TouchData *arg2 = 0 ;
56548
56549   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56550   arg2 = (Dali::TouchData *)jarg2;
56551   if (!arg2) {
56552     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
56553     return ;
56554   }
56555   {
56556     try {
56557       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Emit(arg1,(Dali::TouchData const &)*arg2);
56558     } catch (std::out_of_range& e) {
56559       {
56560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56561       };
56562     } catch (std::exception& e) {
56563       {
56564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56565       };
56566     } catch (Dali::DaliException e) {
56567       {
56568         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56569       };
56570     } catch (...) {
56571       {
56572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56573       };
56574     }
56575   }
56576
56577 }
56578
56579
56580 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchSignal() {
56581   void * jresult ;
56582   Dali::Signal< void (Dali::TouchData const &) > *result = 0 ;
56583
56584   {
56585     try {
56586       result = (Dali::Signal< void (Dali::TouchData const &) > *)new Dali::Signal< void (Dali::TouchData const &) >();
56587     } catch (std::out_of_range& e) {
56588       {
56589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56590       };
56591     } catch (std::exception& e) {
56592       {
56593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56594       };
56595     } catch (Dali::DaliException e) {
56596       {
56597         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56598       };
56599     } catch (...) {
56600       {
56601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56602       };
56603     }
56604   }
56605
56606   jresult = (void *)result;
56607   return jresult;
56608 }
56609
56610
56611 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchSignal(void * jarg1) {
56612   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56613
56614   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56615   {
56616     try {
56617       delete arg1;
56618     } catch (std::out_of_range& e) {
56619       {
56620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56621       };
56622     } catch (std::exception& e) {
56623       {
56624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56625       };
56626     } catch (Dali::DaliException e) {
56627       {
56628         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56629       };
56630     } catch (...) {
56631       {
56632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56633       };
56634     }
56635   }
56636
56637 }
56638
56639
56640 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StageWheelSignal_Empty(void * jarg1) {
56641   unsigned int jresult ;
56642   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56643   bool result;
56644
56645   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56646   {
56647     try {
56648       result = (bool)Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
56649     } catch (std::out_of_range& e) {
56650       {
56651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56652       };
56653     } catch (std::exception& e) {
56654       {
56655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56656       };
56657     } catch (Dali::DaliException e) {
56658       {
56659         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56660       };
56661     } catch (...) {
56662       {
56663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56664       };
56665     }
56666   }
56667
56668   jresult = result;
56669   return jresult;
56670 }
56671
56672
56673 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StageWheelSignal_GetConnectionCount(void * jarg1) {
56674   unsigned long jresult ;
56675   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56676   std::size_t result;
56677
56678   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56679   {
56680     try {
56681       result = Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
56682     } catch (std::out_of_range& e) {
56683       {
56684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56685       };
56686     } catch (std::exception& e) {
56687       {
56688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56689       };
56690     } catch (Dali::DaliException e) {
56691       {
56692         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56693       };
56694     } catch (...) {
56695       {
56696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56697       };
56698     }
56699   }
56700
56701   jresult = (unsigned long)result;
56702   return jresult;
56703 }
56704
56705
56706 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Connect(void * jarg1, void * jarg2) {
56707   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56708   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
56709
56710   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56711   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
56712   {
56713     try {
56714       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
56715     } catch (std::out_of_range& e) {
56716       {
56717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56718       };
56719     } catch (std::exception& e) {
56720       {
56721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56722       };
56723     } catch (Dali::DaliException e) {
56724       {
56725         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56726       };
56727     } catch (...) {
56728       {
56729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56730       };
56731     }
56732   }
56733
56734 }
56735
56736
56737 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Disconnect(void * jarg1, void * jarg2) {
56738   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56739   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
56740
56741   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56742   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
56743   {
56744     try {
56745       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
56746     } catch (std::out_of_range& e) {
56747       {
56748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56749       };
56750     } catch (std::exception& e) {
56751       {
56752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56753       };
56754     } catch (Dali::DaliException e) {
56755       {
56756         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56757       };
56758     } catch (...) {
56759       {
56760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56761       };
56762     }
56763   }
56764
56765 }
56766
56767
56768 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Emit(void * jarg1, void * jarg2) {
56769   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56770   Dali::WheelEvent *arg2 = 0 ;
56771
56772   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56773   arg2 = (Dali::WheelEvent *)jarg2;
56774   if (!arg2) {
56775     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
56776     return ;
56777   }
56778   {
56779     try {
56780       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::WheelEvent const &)*arg2);
56781     } catch (std::out_of_range& e) {
56782       {
56783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56784       };
56785     } catch (std::exception& e) {
56786       {
56787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56788       };
56789     } catch (Dali::DaliException e) {
56790       {
56791         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56792       };
56793     } catch (...) {
56794       {
56795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56796       };
56797     }
56798   }
56799
56800 }
56801
56802
56803 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StageWheelSignal() {
56804   void * jresult ;
56805   Dali::Signal< void (Dali::WheelEvent const &) > *result = 0 ;
56806
56807   {
56808     try {
56809       result = (Dali::Signal< void (Dali::WheelEvent const &) > *)new Dali::Signal< void (Dali::WheelEvent const &) >();
56810     } catch (std::out_of_range& e) {
56811       {
56812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56813       };
56814     } catch (std::exception& e) {
56815       {
56816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56817       };
56818     } catch (Dali::DaliException e) {
56819       {
56820         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56821       };
56822     } catch (...) {
56823       {
56824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56825       };
56826     }
56827   }
56828
56829   jresult = (void *)result;
56830   return jresult;
56831 }
56832
56833
56834 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StageWheelSignal(void * jarg1) {
56835   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56836
56837   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56838   {
56839     try {
56840       delete arg1;
56841     } catch (std::out_of_range& e) {
56842       {
56843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56844       };
56845     } catch (std::exception& e) {
56846       {
56847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56848       };
56849     } catch (Dali::DaliException e) {
56850       {
56851         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56852       };
56853     } catch (...) {
56854       {
56855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56856       };
56857     }
56858   }
56859
56860 }
56861
56862
56863 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_0() {
56864   void * jresult ;
56865   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
56866
56867   {
56868     try {
56869       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >();
56870     } catch (std::out_of_range& e) {
56871       {
56872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56873       };
56874     } catch (std::exception& e) {
56875       {
56876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56877       };
56878     } catch (Dali::DaliException e) {
56879       {
56880         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56881       };
56882     } catch (...) {
56883       {
56884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56885       };
56886     }
56887   }
56888
56889   jresult = (void *)result;
56890   return jresult;
56891 }
56892
56893
56894 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_1(void * jarg1, void * jarg2) {
56895   void * jresult ;
56896   Dali::Radian arg1 ;
56897   Dali::Radian arg2 ;
56898   Dali::Radian *argp1 ;
56899   Dali::Radian *argp2 ;
56900   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
56901
56902   argp1 = (Dali::Radian *)jarg1;
56903   if (!argp1) {
56904     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
56905     return 0;
56906   }
56907   arg1 = *argp1;
56908   argp2 = (Dali::Radian *)jarg2;
56909   if (!argp2) {
56910     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
56911     return 0;
56912   }
56913   arg2 = *argp2;
56914   {
56915     try {
56916       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >(arg1,arg2);
56917     } catch (std::out_of_range& e) {
56918       {
56919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56920       };
56921     } catch (std::exception& e) {
56922       {
56923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56924       };
56925     } catch (Dali::DaliException e) {
56926       {
56927         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56928       };
56929     } catch (...) {
56930       {
56931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56932       };
56933     }
56934   }
56935
56936   jresult = (void *)result;
56937   return jresult;
56938 }
56939
56940
56941 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_2(void * jarg1) {
56942   void * jresult ;
56943   std::pair< Dali::Radian,Dali::Radian > *arg1 = 0 ;
56944   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
56945
56946   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
56947   if (!arg1) {
56948     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< Dali::Radian,Dali::Radian > const & type is null", 0);
56949     return 0;
56950   }
56951   {
56952     try {
56953       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >((std::pair< Dali::Radian,Dali::Radian > const &)*arg1);
56954     } catch (std::out_of_range& e) {
56955       {
56956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56957       };
56958     } catch (std::exception& e) {
56959       {
56960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56961       };
56962     } catch (Dali::DaliException e) {
56963       {
56964         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56965       };
56966     } catch (...) {
56967       {
56968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56969       };
56970     }
56971   }
56972
56973   jresult = (void *)result;
56974   return jresult;
56975 }
56976
56977
56978 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_set(void * jarg1, void * jarg2) {
56979   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
56980   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
56981
56982   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
56983   arg2 = (Dali::Radian *)jarg2;
56984   if (arg1) (arg1)->first = *arg2;
56985 }
56986
56987
56988 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_get(void * jarg1) {
56989   void * jresult ;
56990   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
56991   Dali::Radian *result = 0 ;
56992
56993   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
56994   result = (Dali::Radian *)& ((arg1)->first);
56995   jresult = (void *)result;
56996   return jresult;
56997 }
56998
56999
57000 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_set(void * jarg1, void * jarg2) {
57001   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
57002   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
57003
57004   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
57005   arg2 = (Dali::Radian *)jarg2;
57006   if (arg1) (arg1)->second = *arg2;
57007 }
57008
57009
57010 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_get(void * jarg1) {
57011   void * jresult ;
57012   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
57013   Dali::Radian *result = 0 ;
57014
57015   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
57016   result = (Dali::Radian *)& ((arg1)->second);
57017   jresult = (void *)result;
57018   return jresult;
57019 }
57020
57021
57022 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleThresholdPair(void * jarg1) {
57023   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
57024
57025   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
57026   {
57027     try {
57028       delete arg1;
57029     } catch (std::out_of_range& e) {
57030       {
57031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57032       };
57033     } catch (std::exception& e) {
57034       {
57035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57036       };
57037     } catch (Dali::DaliException e) {
57038       {
57039         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57040       };
57041     } catch (...) {
57042       {
57043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57044       };
57045     }
57046   }
57047
57048 }
57049
57050
57051 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Empty(void * jarg1) {
57052   unsigned int jresult ;
57053   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57054   bool result;
57055
57056   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57057   {
57058     try {
57059       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);
57060     } catch (std::out_of_range& e) {
57061       {
57062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57063       };
57064     } catch (std::exception& e) {
57065       {
57066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57067       };
57068     } catch (Dali::DaliException e) {
57069       {
57070         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57071       };
57072     } catch (...) {
57073       {
57074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57075       };
57076     }
57077   }
57078
57079   jresult = result;
57080   return jresult;
57081 }
57082
57083
57084 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_GetConnectionCount(void * jarg1) {
57085   unsigned long jresult ;
57086   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57087   std::size_t result;
57088
57089   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57090   {
57091     try {
57092       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);
57093     } catch (std::out_of_range& e) {
57094       {
57095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57096       };
57097     } catch (std::exception& e) {
57098       {
57099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57100       };
57101     } catch (Dali::DaliException e) {
57102       {
57103         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57104       };
57105     } catch (...) {
57106       {
57107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57108       };
57109     }
57110   }
57111
57112   jresult = (unsigned long)result;
57113   return jresult;
57114 }
57115
57116
57117 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
57118   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57119   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
57120
57121   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57122   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
57123   {
57124     try {
57125       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
57126     } catch (std::out_of_range& e) {
57127       {
57128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57129       };
57130     } catch (std::exception& e) {
57131       {
57132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57133       };
57134     } catch (Dali::DaliException e) {
57135       {
57136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57137       };
57138     } catch (...) {
57139       {
57140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57141       };
57142     }
57143   }
57144
57145 }
57146
57147
57148 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
57149   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57150   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
57151
57152   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57153   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
57154   {
57155     try {
57156       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
57157     } catch (std::out_of_range& e) {
57158       {
57159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57160       };
57161     } catch (std::exception& e) {
57162       {
57163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57164       };
57165     } catch (Dali::DaliException e) {
57166       {
57167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57168       };
57169     } catch (...) {
57170       {
57171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57172       };
57173     }
57174   }
57175
57176 }
57177
57178
57179 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
57180   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57181   Dali::Actor arg2 ;
57182   Dali::PanGesture *arg3 = 0 ;
57183   Dali::Actor *argp2 ;
57184
57185   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57186   argp2 = (Dali::Actor *)jarg2;
57187   if (!argp2) {
57188     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57189     return ;
57190   }
57191   arg2 = *argp2;
57192   arg3 = (Dali::PanGesture *)jarg3;
57193   if (!arg3) {
57194     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
57195     return ;
57196   }
57197   {
57198     try {
57199       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PanGesture const &)*arg3);
57200     } catch (std::out_of_range& e) {
57201       {
57202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57203       };
57204     } catch (std::exception& e) {
57205       {
57206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57207       };
57208     } catch (Dali::DaliException e) {
57209       {
57210         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57211       };
57212     } catch (...) {
57213       {
57214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57215       };
57216     }
57217   }
57218
57219 }
57220
57221
57222 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetectedSignal() {
57223   void * jresult ;
57224   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *result = 0 ;
57225
57226   {
57227     try {
57228       result = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) >();
57229     } catch (std::out_of_range& e) {
57230       {
57231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57232       };
57233     } catch (std::exception& e) {
57234       {
57235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57236       };
57237     } catch (Dali::DaliException e) {
57238       {
57239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57240       };
57241     } catch (...) {
57242       {
57243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57244       };
57245     }
57246   }
57247
57248   jresult = (void *)result;
57249   return jresult;
57250 }
57251
57252
57253 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetectedSignal(void * jarg1) {
57254   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57255
57256   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57257   {
57258     try {
57259       delete arg1;
57260     } catch (std::out_of_range& e) {
57261       {
57262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57263       };
57264     } catch (std::exception& e) {
57265       {
57266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57267       };
57268     } catch (Dali::DaliException e) {
57269       {
57270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57271       };
57272     } catch (...) {
57273       {
57274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57275       };
57276     }
57277   }
57278
57279 }
57280
57281
57282 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Empty(void * jarg1) {
57283   unsigned int jresult ;
57284   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57285   bool result;
57286
57287   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57288   {
57289     try {
57290       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);
57291     } catch (std::out_of_range& e) {
57292       {
57293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57294       };
57295     } catch (std::exception& e) {
57296       {
57297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57298       };
57299     } catch (Dali::DaliException e) {
57300       {
57301         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57302       };
57303     } catch (...) {
57304       {
57305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57306       };
57307     }
57308   }
57309
57310   jresult = result;
57311   return jresult;
57312 }
57313
57314
57315 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_GetConnectionCount(void * jarg1) {
57316   unsigned long jresult ;
57317   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57318   std::size_t result;
57319
57320   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57321   {
57322     try {
57323       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);
57324     } catch (std::out_of_range& e) {
57325       {
57326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57327       };
57328     } catch (std::exception& e) {
57329       {
57330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57331       };
57332     } catch (Dali::DaliException e) {
57333       {
57334         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57335       };
57336     } catch (...) {
57337       {
57338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57339       };
57340     }
57341   }
57342
57343   jresult = (unsigned long)result;
57344   return jresult;
57345 }
57346
57347
57348 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
57349   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57350   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
57351
57352   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57353   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
57354   {
57355     try {
57356       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
57357     } catch (std::out_of_range& e) {
57358       {
57359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57360       };
57361     } catch (std::exception& e) {
57362       {
57363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57364       };
57365     } catch (Dali::DaliException e) {
57366       {
57367         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57368       };
57369     } catch (...) {
57370       {
57371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57372       };
57373     }
57374   }
57375
57376 }
57377
57378
57379 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
57380   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57381   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
57382
57383   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57384   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
57385   {
57386     try {
57387       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
57388     } catch (std::out_of_range& e) {
57389       {
57390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57391       };
57392     } catch (std::exception& e) {
57393       {
57394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57395       };
57396     } catch (Dali::DaliException e) {
57397       {
57398         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57399       };
57400     } catch (...) {
57401       {
57402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57403       };
57404     }
57405   }
57406
57407 }
57408
57409
57410 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
57411   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57412   Dali::Actor arg2 ;
57413   Dali::PinchGesture *arg3 = 0 ;
57414   Dali::Actor *argp2 ;
57415
57416   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57417   argp2 = (Dali::Actor *)jarg2;
57418   if (!argp2) {
57419     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57420     return ;
57421   }
57422   arg2 = *argp2;
57423   arg3 = (Dali::PinchGesture *)jarg3;
57424   if (!arg3) {
57425     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
57426     return ;
57427   }
57428   {
57429     try {
57430       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PinchGesture const &)*arg3);
57431     } catch (std::out_of_range& e) {
57432       {
57433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57434       };
57435     } catch (std::exception& e) {
57436       {
57437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57438       };
57439     } catch (Dali::DaliException e) {
57440       {
57441         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57442       };
57443     } catch (...) {
57444       {
57445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57446       };
57447     }
57448   }
57449
57450 }
57451
57452
57453 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetectedSignal() {
57454   void * jresult ;
57455   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *result = 0 ;
57456
57457   {
57458     try {
57459       result = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) >();
57460     } catch (std::out_of_range& e) {
57461       {
57462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57463       };
57464     } catch (std::exception& e) {
57465       {
57466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57467       };
57468     } catch (Dali::DaliException e) {
57469       {
57470         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57471       };
57472     } catch (...) {
57473       {
57474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57475       };
57476     }
57477   }
57478
57479   jresult = (void *)result;
57480   return jresult;
57481 }
57482
57483
57484 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetectedSignal(void * jarg1) {
57485   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57486
57487   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57488   {
57489     try {
57490       delete arg1;
57491     } catch (std::out_of_range& e) {
57492       {
57493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57494       };
57495     } catch (std::exception& e) {
57496       {
57497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57498       };
57499     } catch (Dali::DaliException e) {
57500       {
57501         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57502       };
57503     } catch (...) {
57504       {
57505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57506       };
57507     }
57508   }
57509
57510 }
57511
57512
57513 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Empty(void * jarg1) {
57514   unsigned int jresult ;
57515   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57516   bool result;
57517
57518   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57519   {
57520     try {
57521       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);
57522     } catch (std::out_of_range& e) {
57523       {
57524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57525       };
57526     } catch (std::exception& e) {
57527       {
57528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57529       };
57530     } catch (Dali::DaliException e) {
57531       {
57532         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57533       };
57534     } catch (...) {
57535       {
57536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57537       };
57538     }
57539   }
57540
57541   jresult = result;
57542   return jresult;
57543 }
57544
57545
57546 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_GetConnectionCount(void * jarg1) {
57547   unsigned long jresult ;
57548   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57549   std::size_t result;
57550
57551   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57552   {
57553     try {
57554       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);
57555     } catch (std::out_of_range& e) {
57556       {
57557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57558       };
57559     } catch (std::exception& e) {
57560       {
57561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57562       };
57563     } catch (Dali::DaliException e) {
57564       {
57565         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57566       };
57567     } catch (...) {
57568       {
57569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57570       };
57571     }
57572   }
57573
57574   jresult = (unsigned long)result;
57575   return jresult;
57576 }
57577
57578
57579 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
57580   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57581   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
57582
57583   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57584   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
57585   {
57586     try {
57587       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
57588     } catch (std::out_of_range& e) {
57589       {
57590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57591       };
57592     } catch (std::exception& e) {
57593       {
57594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57595       };
57596     } catch (Dali::DaliException e) {
57597       {
57598         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57599       };
57600     } catch (...) {
57601       {
57602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57603       };
57604     }
57605   }
57606
57607 }
57608
57609
57610 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
57611   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57612   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
57613
57614   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57615   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
57616   {
57617     try {
57618       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
57619     } catch (std::out_of_range& e) {
57620       {
57621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57622       };
57623     } catch (std::exception& e) {
57624       {
57625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57626       };
57627     } catch (Dali::DaliException e) {
57628       {
57629         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57630       };
57631     } catch (...) {
57632       {
57633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57634       };
57635     }
57636   }
57637
57638 }
57639
57640
57641 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
57642   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57643   Dali::Actor arg2 ;
57644   Dali::TapGesture *arg3 = 0 ;
57645   Dali::Actor *argp2 ;
57646
57647   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57648   argp2 = (Dali::Actor *)jarg2;
57649   if (!argp2) {
57650     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57651     return ;
57652   }
57653   arg2 = *argp2;
57654   arg3 = (Dali::TapGesture *)jarg3;
57655   if (!arg3) {
57656     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
57657     return ;
57658   }
57659   {
57660     try {
57661       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TapGesture const &)*arg3);
57662     } catch (std::out_of_range& e) {
57663       {
57664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57665       };
57666     } catch (std::exception& e) {
57667       {
57668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57669       };
57670     } catch (Dali::DaliException e) {
57671       {
57672         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57673       };
57674     } catch (...) {
57675       {
57676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57677       };
57678     }
57679   }
57680
57681 }
57682
57683
57684 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetectedSignal() {
57685   void * jresult ;
57686   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *result = 0 ;
57687
57688   {
57689     try {
57690       result = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) >();
57691     } catch (std::out_of_range& e) {
57692       {
57693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57694       };
57695     } catch (std::exception& e) {
57696       {
57697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57698       };
57699     } catch (Dali::DaliException e) {
57700       {
57701         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57702       };
57703     } catch (...) {
57704       {
57705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57706       };
57707     }
57708   }
57709
57710   jresult = (void *)result;
57711   return jresult;
57712 }
57713
57714
57715 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetectedSignal(void * jarg1) {
57716   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57717
57718   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57719   {
57720     try {
57721       delete arg1;
57722     } catch (std::out_of_range& e) {
57723       {
57724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57725       };
57726     } catch (std::exception& e) {
57727       {
57728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57729       };
57730     } catch (Dali::DaliException e) {
57731       {
57732         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57733       };
57734     } catch (...) {
57735       {
57736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57737       };
57738     }
57739   }
57740
57741 }
57742
57743 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Empty(void * jarg1) {
57744   unsigned int jresult ;
57745   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57746   bool result;
57747
57748   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57749   {
57750     try {
57751       result = (bool)Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Empty((Dali::Signal< void (Dali::ResourceImage) > const *)arg1);
57752     } catch (std::out_of_range& e) {
57753       {
57754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57755       };
57756     } catch (std::exception& e) {
57757       {
57758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57759       };
57760     } catch (Dali::DaliException e) {
57761       {
57762         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57763       };
57764     } catch (...) {
57765       {
57766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57767       };
57768     }
57769   }
57770
57771   jresult = result;
57772   return jresult;
57773 }
57774
57775
57776 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ResourceImageSignal_GetConnectionCount(void * jarg1) {
57777   unsigned long jresult ;
57778   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57779   std::size_t result;
57780
57781   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57782   {
57783     try {
57784       result = Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::ResourceImage) > const *)arg1);
57785     } catch (std::out_of_range& e) {
57786       {
57787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57788       };
57789     } catch (std::exception& e) {
57790       {
57791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57792       };
57793     } catch (Dali::DaliException e) {
57794       {
57795         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57796       };
57797     } catch (...) {
57798       {
57799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57800       };
57801     }
57802   }
57803
57804   jresult = (unsigned long)result;
57805   return jresult;
57806 }
57807
57808
57809 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Connect(void * jarg1, void * jarg2) {
57810   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57811   void (*arg2)(Dali::ResourceImage) = (void (*)(Dali::ResourceImage)) 0 ;
57812
57813   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57814   arg2 = (void (*)(Dali::ResourceImage))jarg2;
57815   {
57816     try {
57817       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Connect(arg1,arg2);
57818     } catch (std::out_of_range& e) {
57819       {
57820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57821       };
57822     } catch (std::exception& e) {
57823       {
57824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57825       };
57826     } catch (Dali::DaliException e) {
57827       {
57828         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57829       };
57830     } catch (...) {
57831       {
57832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57833       };
57834     }
57835   }
57836
57837 }
57838
57839
57840 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Disconnect(void * jarg1, void * jarg2) {
57841   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57842   void (*arg2)(Dali::ResourceImage) = (void (*)(Dali::ResourceImage)) 0 ;
57843
57844   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57845   arg2 = (void (*)(Dali::ResourceImage))jarg2;
57846   {
57847     try {
57848       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Disconnect(arg1,arg2);
57849     } catch (std::out_of_range& e) {
57850       {
57851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57852       };
57853     } catch (std::exception& e) {
57854       {
57855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57856       };
57857     } catch (Dali::DaliException e) {
57858       {
57859         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57860       };
57861     } catch (...) {
57862       {
57863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57864       };
57865     }
57866   }
57867
57868 }
57869
57870
57871 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Emit(void * jarg1, void * jarg2) {
57872   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57873   Dali::ResourceImage arg2 ;
57874   Dali::ResourceImage *argp2 ;
57875
57876   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57877   argp2 = (Dali::ResourceImage *)jarg2;
57878   if (!argp2) {
57879     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ResourceImage", 0);
57880     return ;
57881   }
57882   arg2 = *argp2;
57883   {
57884     try {
57885       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Emit(arg1,arg2);
57886     } catch (std::out_of_range& e) {
57887       {
57888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57889       };
57890     } catch (std::exception& e) {
57891       {
57892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57893       };
57894     } catch (Dali::DaliException e) {
57895       {
57896         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57897       };
57898     } catch (...) {
57899       {
57900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57901       };
57902     }
57903   }
57904
57905 }
57906
57907
57908 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImageSignal() {
57909   void * jresult ;
57910   Dali::Signal< void (Dali::ResourceImage) > *result = 0 ;
57911
57912   {
57913     try {
57914       result = (Dali::Signal< void (Dali::ResourceImage) > *)new Dali::Signal< void (Dali::ResourceImage) >();
57915     } catch (std::out_of_range& e) {
57916       {
57917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57918       };
57919     } catch (std::exception& e) {
57920       {
57921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57922       };
57923     } catch (Dali::DaliException e) {
57924       {
57925         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57926       };
57927     } catch (...) {
57928       {
57929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57930       };
57931     }
57932   }
57933
57934   jresult = (void *)result;
57935   return jresult;
57936 }
57937
57938
57939 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ResourceImageSignal(void * jarg1) {
57940   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57941
57942   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57943   {
57944     try {
57945       delete arg1;
57946     } catch (std::out_of_range& e) {
57947       {
57948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57949       };
57950     } catch (std::exception& e) {
57951       {
57952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57953       };
57954     } catch (Dali::DaliException e) {
57955       {
57956         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57957       };
57958     } catch (...) {
57959       {
57960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57961       };
57962     }
57963   }
57964
57965 }
57966
57967 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionChangedSignal_Empty(void * jarg1) {
57968   unsigned int jresult ;
57969   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
57970   bool result = false;
57971
57972   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
57973   {
57974     try {
57975       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);
57976     } catch (std::out_of_range& e) {
57977       {
57978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57979       };
57980     } catch (std::exception& e) {
57981       {
57982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57983       };
57984     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
57985   }
57986   jresult = result;
57987   return jresult;
57988 }
57989
57990 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_GetConnectionCount(void * jarg1) {
57991   unsigned long jresult ;
57992   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
57993   std::size_t result = 0;
57994
57995   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
57996   {
57997     try {
57998       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);
57999     } catch (std::out_of_range& e) {
58000       {
58001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58002       };
58003     } catch (std::exception& e) {
58004       {
58005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58006       };
58007     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58008   }
58009   jresult = (unsigned long)result;
58010   return jresult;
58011 }
58012
58013 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Connect(void * jarg1, void * jarg2) {
58014   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
58015   void (*arg2)(Dali::Actor, Dali::LayoutDirection::Type) = (void (*)(Dali::Actor, Dali::LayoutDirection::Type)) 0 ;
58016
58017   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
58018   arg2 = (void (*)(Dali::Actor, Dali::LayoutDirection::Type))jarg2;
58019   {
58020     try {
58021       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Connect(arg1,arg2);
58022     } catch (std::out_of_range& e) {
58023       {
58024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58025       };
58026     } catch (std::exception& e) {
58027       {
58028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58029       };
58030     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58031   }
58032 }
58033
58034 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Disconnect(void * jarg1, void * jarg2) {
58035   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
58036   void (*arg2)(Dali::Actor, Dali::LayoutDirection::Type) = (void (*)(Dali::Actor, Dali::LayoutDirection::Type)) 0 ;
58037
58038   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
58039   arg2 = (void (*)(Dali::Actor, Dali::LayoutDirection::Type))jarg2;
58040   {
58041     try {
58042       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Disconnect(arg1,arg2);
58043     } catch (std::out_of_range& e) {
58044       {
58045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58046       };
58047     } catch (std::exception& e) {
58048       {
58049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58050       };
58051     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58052   }
58053 }
58054
58055 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Emit(void * jarg1, void * jarg2, int jarg4) {
58056   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
58057   Dali::Actor arg2 ;
58058   //bool arg3 ;
58059   Dali::LayoutDirection::Type arg4 ;
58060   Dali::Actor *argp2 ;
58061
58062   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
58063   argp2 = (Dali::Actor *)jarg2;
58064   if (!argp2) {
58065     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
58066     return ;
58067   }
58068   arg2 = *argp2;
58069   //arg3 = jarg3 ? true : false;
58070   arg4 = (Dali::LayoutDirection::Type)jarg4;
58071   {
58072     try {
58073       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Emit(arg1,arg2,arg4);
58074     } catch (std::out_of_range& e) {
58075       {
58076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58077       };
58078     } catch (std::exception& e) {
58079       {
58080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58081       };
58082     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58083   }
58084 }
58085
58086 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewLayoutDirectionSignal() {
58087   void * jresult ;
58088   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *result = 0 ;
58089
58090   {
58091     try {
58092       result = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)new Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) >();
58093     } catch (std::out_of_range& e) {
58094       {
58095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58096       };
58097     } catch (std::exception& e) {
58098       {
58099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58100       };
58101     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58102   }
58103   jresult = (void *)result;
58104   return jresult;
58105 }
58106
58107 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewLayoutDirectionSignal(void * jarg1) {
58108   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
58109
58110   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
58111   {
58112     try {
58113       delete arg1;
58114     } catch (std::out_of_range& e) {
58115       {
58116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58117       };
58118     } catch (std::exception& e) {
58119       {
58120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58121       };
58122     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58123   }
58124 }
58125
58126 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Empty(void * jarg1) {
58127   unsigned int jresult ;
58128   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58129   bool result;
58130
58131   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58132   {
58133     try {
58134       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);
58135     } catch (std::out_of_range& e) {
58136       {
58137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58138       };
58139     } catch (std::exception& e) {
58140       {
58141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58142       };
58143     } catch (Dali::DaliException e) {
58144       {
58145         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58146       };
58147     } catch (...) {
58148       {
58149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58150       };
58151     }
58152   }
58153
58154   jresult = result;
58155   return jresult;
58156 }
58157
58158
58159 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_GetConnectionCount(void * jarg1) {
58160   unsigned long jresult ;
58161   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58162   std::size_t result;
58163
58164   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58165   {
58166     try {
58167       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);
58168     } catch (std::out_of_range& e) {
58169       {
58170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58171       };
58172     } catch (std::exception& e) {
58173       {
58174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58175       };
58176     } catch (Dali::DaliException e) {
58177       {
58178         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58179       };
58180     } catch (...) {
58181       {
58182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58183       };
58184     }
58185   }
58186
58187   jresult = (unsigned long)result;
58188   return jresult;
58189 }
58190
58191
58192 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Connect(void * jarg1, void * jarg2) {
58193   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58194   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
58195
58196   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58197   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
58198   {
58199     try {
58200       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Connect(arg1,arg2);
58201     } catch (std::out_of_range& e) {
58202       {
58203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58204       };
58205     } catch (std::exception& e) {
58206       {
58207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58208       };
58209     } catch (Dali::DaliException e) {
58210       {
58211         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58212       };
58213     } catch (...) {
58214       {
58215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58216       };
58217     }
58218   }
58219
58220 }
58221
58222
58223 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Disconnect(void * jarg1, void * jarg2) {
58224   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58225   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
58226
58227   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58228   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
58229   {
58230     try {
58231       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Disconnect(arg1,arg2);
58232     } catch (std::out_of_range& e) {
58233       {
58234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58235       };
58236     } catch (std::exception& e) {
58237       {
58238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58239       };
58240     } catch (Dali::DaliException e) {
58241       {
58242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58243       };
58244     } catch (...) {
58245       {
58246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58247       };
58248     }
58249   }
58250
58251 }
58252
58253
58254 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, int jarg4) {
58255   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58256   Dali::Actor arg2 ;
58257   bool arg3 ;
58258   Dali::DevelActor::VisibilityChange::Type arg4 ;
58259   Dali::Actor *argp2 ;
58260
58261   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58262   argp2 = (Dali::Actor *)jarg2;
58263   if (!argp2) {
58264     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
58265     return ;
58266   }
58267   arg2 = *argp2;
58268   arg3 = jarg3 ? true : false;
58269   arg4 = (Dali::DevelActor::VisibilityChange::Type)jarg4;
58270   {
58271     try {
58272       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Emit(arg1,arg2,arg3,arg4);
58273     } catch (std::out_of_range& e) {
58274       {
58275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58276       };
58277     } catch (std::exception& e) {
58278       {
58279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58280       };
58281     } catch (Dali::DaliException e) {
58282       {
58283         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58284       };
58285     } catch (...) {
58286       {
58287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58288       };
58289     }
58290   }
58291
58292 }
58293
58294
58295 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewVisibilityChangedSignal() {
58296   void * jresult ;
58297   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *result = 0 ;
58298
58299   {
58300     try {
58301       result = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)new Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) >();
58302     } catch (std::out_of_range& e) {
58303       {
58304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58305       };
58306     } catch (std::exception& e) {
58307       {
58308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58309       };
58310     } catch (Dali::DaliException e) {
58311       {
58312         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58313       };
58314     } catch (...) {
58315       {
58316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58317       };
58318     }
58319   }
58320
58321   jresult = (void *)result;
58322   return jresult;
58323 }
58324
58325
58326 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewVisibilityChangedSignal(void * jarg1) {
58327   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58328
58329   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58330   {
58331     try {
58332       delete arg1;
58333     } catch (std::out_of_range& e) {
58334       {
58335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58336       };
58337     } catch (std::exception& e) {
58338       {
58339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58340       };
58341     } catch (Dali::DaliException e) {
58342       {
58343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58344       };
58345     } catch (...) {
58346       {
58347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58348       };
58349     }
58350   }
58351
58352 }
58353
58354
58355 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_0() {
58356   void * jresult ;
58357   Dali::Timer *result = 0 ;
58358
58359   {
58360     try {
58361       result = (Dali::Timer *)new Dali::Timer();
58362     } catch (std::out_of_range& e) {
58363       {
58364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58365       };
58366     } catch (std::exception& e) {
58367       {
58368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58369       };
58370     } catch (Dali::DaliException e) {
58371       {
58372         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58373       };
58374     } catch (...) {
58375       {
58376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58377       };
58378     }
58379   }
58380
58381   jresult = (void *)result;
58382   return jresult;
58383 }
58384
58385
58386 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_New(unsigned int jarg1) {
58387   void * jresult ;
58388   unsigned int arg1 ;
58389   Dali::Timer result;
58390
58391   arg1 = (unsigned int)jarg1;
58392   {
58393     try {
58394       result = Dali::Timer::New(arg1);
58395     } catch (std::out_of_range& e) {
58396       {
58397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58398       };
58399     } catch (std::exception& e) {
58400       {
58401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58402       };
58403     } catch (Dali::DaliException e) {
58404       {
58405         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58406       };
58407     } catch (...) {
58408       {
58409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58410       };
58411     }
58412   }
58413
58414   jresult = new Dali::Timer((const Dali::Timer &)result);
58415   return jresult;
58416 }
58417
58418
58419 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_1(void * jarg1) {
58420   void * jresult ;
58421   Dali::Timer *arg1 = 0 ;
58422   Dali::Timer *result = 0 ;
58423
58424   arg1 = (Dali::Timer *)jarg1;
58425   if (!arg1) {
58426     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
58427     return 0;
58428   }
58429   {
58430     try {
58431       result = (Dali::Timer *)new Dali::Timer((Dali::Timer const &)*arg1);
58432     } catch (std::out_of_range& e) {
58433       {
58434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58435       };
58436     } catch (std::exception& e) {
58437       {
58438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58439       };
58440     } catch (Dali::DaliException e) {
58441       {
58442         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58443       };
58444     } catch (...) {
58445       {
58446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58447       };
58448     }
58449   }
58450
58451   jresult = (void *)result;
58452   return jresult;
58453 }
58454
58455
58456 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_Assign(void * jarg1, void * jarg2) {
58457   void * jresult ;
58458   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58459   Dali::Timer *arg2 = 0 ;
58460   Dali::Timer *result = 0 ;
58461
58462   arg1 = (Dali::Timer *)jarg1;
58463   arg2 = (Dali::Timer *)jarg2;
58464   if (!arg2) {
58465     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
58466     return 0;
58467   }
58468   {
58469     try {
58470       result = (Dali::Timer *) &(arg1)->operator =((Dali::Timer const &)*arg2);
58471     } catch (std::out_of_range& e) {
58472       {
58473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58474       };
58475     } catch (std::exception& e) {
58476       {
58477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58478       };
58479     } catch (Dali::DaliException e) {
58480       {
58481         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58482       };
58483     } catch (...) {
58484       {
58485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58486       };
58487     }
58488   }
58489
58490   jresult = (void *)result;
58491   return jresult;
58492 }
58493
58494
58495 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Timer(void * jarg1) {
58496   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58497
58498   arg1 = (Dali::Timer *)jarg1;
58499   {
58500     try {
58501       delete arg1;
58502     } catch (std::out_of_range& e) {
58503       {
58504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58505       };
58506     } catch (std::exception& e) {
58507       {
58508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58509       };
58510     } catch (Dali::DaliException e) {
58511       {
58512         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58513       };
58514     } catch (...) {
58515       {
58516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58517       };
58518     }
58519   }
58520
58521 }
58522
58523
58524 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_DownCast(void * jarg1) {
58525   void * jresult ;
58526   Dali::BaseHandle arg1 ;
58527   Dali::BaseHandle *argp1 ;
58528   Dali::Timer result;
58529
58530   argp1 = (Dali::BaseHandle *)jarg1;
58531   if (!argp1) {
58532     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
58533     return 0;
58534   }
58535   arg1 = *argp1;
58536   {
58537     try {
58538       result = Dali::Timer::DownCast(arg1);
58539     } catch (std::out_of_range& e) {
58540       {
58541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58542       };
58543     } catch (std::exception& e) {
58544       {
58545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58546       };
58547     } catch (Dali::DaliException e) {
58548       {
58549         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58550       };
58551     } catch (...) {
58552       {
58553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58554       };
58555     }
58556   }
58557
58558   jresult = new Dali::Timer((const Dali::Timer &)result);
58559   return jresult;
58560 }
58561
58562
58563 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Start(void * jarg1) {
58564   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58565
58566   arg1 = (Dali::Timer *)jarg1;
58567   {
58568     try {
58569       (arg1)->Start();
58570     } catch (std::out_of_range& e) {
58571       {
58572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58573       };
58574     } catch (std::exception& e) {
58575       {
58576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58577       };
58578     } catch (Dali::DaliException e) {
58579       {
58580         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58581       };
58582     } catch (...) {
58583       {
58584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58585       };
58586     }
58587   }
58588
58589 }
58590
58591
58592 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Stop(void * jarg1) {
58593   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58594
58595   arg1 = (Dali::Timer *)jarg1;
58596   {
58597     try {
58598       (arg1)->Stop();
58599     } catch (std::out_of_range& e) {
58600       {
58601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58602       };
58603     } catch (std::exception& e) {
58604       {
58605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58606       };
58607     } catch (Dali::DaliException e) {
58608       {
58609         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58610       };
58611     } catch (...) {
58612       {
58613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58614       };
58615     }
58616   }
58617
58618 }
58619
58620
58621 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_SetInterval(void * jarg1, unsigned int jarg2) {
58622   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58623   unsigned int arg2 ;
58624
58625   arg1 = (Dali::Timer *)jarg1;
58626   arg2 = (unsigned int)jarg2;
58627   {
58628     try {
58629       (arg1)->SetInterval(arg2);
58630     } catch (std::out_of_range& e) {
58631       {
58632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58633       };
58634     } catch (std::exception& e) {
58635       {
58636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58637       };
58638     } catch (Dali::DaliException e) {
58639       {
58640         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58641       };
58642     } catch (...) {
58643       {
58644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58645       };
58646     }
58647   }
58648
58649 }
58650
58651
58652 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_GetInterval(void * jarg1) {
58653   unsigned int jresult ;
58654   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58655   unsigned int result;
58656
58657   arg1 = (Dali::Timer *)jarg1;
58658   {
58659     try {
58660       result = (unsigned int)((Dali::Timer const *)arg1)->GetInterval();
58661     } catch (std::out_of_range& e) {
58662       {
58663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58664       };
58665     } catch (std::exception& e) {
58666       {
58667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58668       };
58669     } catch (Dali::DaliException e) {
58670       {
58671         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58672       };
58673     } catch (...) {
58674       {
58675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58676       };
58677     }
58678   }
58679
58680   jresult = result;
58681   return jresult;
58682 }
58683
58684
58685 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_IsRunning(void * jarg1) {
58686   unsigned int jresult ;
58687   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58688   bool result;
58689
58690   arg1 = (Dali::Timer *)jarg1;
58691   {
58692     try {
58693       result = (bool)((Dali::Timer const *)arg1)->IsRunning();
58694     } catch (std::out_of_range& e) {
58695       {
58696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58697       };
58698     } catch (std::exception& e) {
58699       {
58700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58701       };
58702     } catch (Dali::DaliException e) {
58703       {
58704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58705       };
58706     } catch (...) {
58707       {
58708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58709       };
58710     }
58711   }
58712
58713   jresult = result;
58714   return jresult;
58715 }
58716
58717
58718 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_TickSignal(void * jarg1) {
58719   void * jresult ;
58720   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58721   Dali::Timer::TimerSignalType *result = 0 ;
58722
58723   arg1 = (Dali::Timer *)jarg1;
58724   {
58725     try {
58726       result = (Dali::Timer::TimerSignalType *) &(arg1)->TickSignal();
58727     } catch (std::out_of_range& e) {
58728       {
58729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58730       };
58731     } catch (std::exception& e) {
58732       {
58733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58734       };
58735     } catch (Dali::DaliException e) {
58736       {
58737         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58738       };
58739     } catch (...) {
58740       {
58741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58742       };
58743     }
58744   }
58745
58746   jresult = (void *)result;
58747   return jresult;
58748 }
58749
58750
58751 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DragAndDropDetector() {
58752   void * jresult ;
58753   Dali::DragAndDropDetector *result = 0 ;
58754
58755   {
58756     try {
58757       result = (Dali::DragAndDropDetector *)new Dali::DragAndDropDetector();
58758     } catch (std::out_of_range& e) {
58759       {
58760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58761       };
58762     } catch (std::exception& e) {
58763       {
58764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58765       };
58766     } catch (Dali::DaliException e) {
58767       {
58768         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58769       };
58770     } catch (...) {
58771       {
58772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58773       };
58774     }
58775   }
58776
58777   jresult = (void *)result;
58778   return jresult;
58779 }
58780
58781
58782 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DragAndDropDetector(void * jarg1) {
58783   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
58784
58785   arg1 = (Dali::DragAndDropDetector *)jarg1;
58786   {
58787     try {
58788       delete arg1;
58789     } catch (std::out_of_range& e) {
58790       {
58791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58792       };
58793     } catch (std::exception& e) {
58794       {
58795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58796       };
58797     } catch (Dali::DaliException e) {
58798       {
58799         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58800       };
58801     } catch (...) {
58802       {
58803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58804       };
58805     }
58806   }
58807
58808 }
58809
58810
58811 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_GetContent(void * jarg1) {
58812   char * jresult ;
58813   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
58814   std::string *result = 0 ;
58815
58816   arg1 = (Dali::DragAndDropDetector *)jarg1;
58817   {
58818     try {
58819       result = (std::string *) &((Dali::DragAndDropDetector const *)arg1)->GetContent();
58820     } catch (std::out_of_range& e) {
58821       {
58822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58823       };
58824     } catch (std::exception& e) {
58825       {
58826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58827       };
58828     } catch (Dali::DaliException e) {
58829       {
58830         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58831       };
58832     } catch (...) {
58833       {
58834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58835       };
58836     }
58837   }
58838
58839   jresult = SWIG_csharp_string_callback(result->c_str());
58840   return jresult;
58841 }
58842
58843
58844 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_GetCurrentScreenPosition(void * jarg1) {
58845   void * jresult ;
58846   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
58847   Dali::Vector2 result;
58848
58849   arg1 = (Dali::DragAndDropDetector *)jarg1;
58850   {
58851     try {
58852       result = ((Dali::DragAndDropDetector const *)arg1)->GetCurrentScreenPosition();
58853     } catch (std::out_of_range& e) {
58854       {
58855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58856       };
58857     } catch (std::exception& e) {
58858       {
58859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58860       };
58861     } catch (Dali::DaliException e) {
58862       {
58863         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58864       };
58865     } catch (...) {
58866       {
58867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58868       };
58869     }
58870   }
58871
58872   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
58873   return jresult;
58874 }
58875
58876
58877 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_EnteredSignal(void * jarg1) {
58878   void * jresult ;
58879   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
58880   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
58881
58882   arg1 = (Dali::DragAndDropDetector *)jarg1;
58883   {
58884     try {
58885       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->EnteredSignal();
58886     } catch (std::out_of_range& e) {
58887       {
58888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58889       };
58890     } catch (std::exception& e) {
58891       {
58892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58893       };
58894     } catch (Dali::DaliException e) {
58895       {
58896         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58897       };
58898     } catch (...) {
58899       {
58900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58901       };
58902     }
58903   }
58904
58905   jresult = (void *)result;
58906   return jresult;
58907 }
58908
58909
58910 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_ExitedSignal(void * jarg1) {
58911   void * jresult ;
58912   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
58913   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
58914
58915   arg1 = (Dali::DragAndDropDetector *)jarg1;
58916   {
58917     try {
58918       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->ExitedSignal();
58919     } catch (std::out_of_range& e) {
58920       {
58921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58922       };
58923     } catch (std::exception& e) {
58924       {
58925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58926       };
58927     } catch (Dali::DaliException e) {
58928       {
58929         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58930       };
58931     } catch (...) {
58932       {
58933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58934       };
58935     }
58936   }
58937
58938   jresult = (void *)result;
58939   return jresult;
58940 }
58941
58942
58943 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_MovedSignal(void * jarg1) {
58944   void * jresult ;
58945   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
58946   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
58947
58948   arg1 = (Dali::DragAndDropDetector *)jarg1;
58949   {
58950     try {
58951       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->MovedSignal();
58952     } catch (std::out_of_range& e) {
58953       {
58954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58955       };
58956     } catch (std::exception& e) {
58957       {
58958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58959       };
58960     } catch (Dali::DaliException e) {
58961       {
58962         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58963       };
58964     } catch (...) {
58965       {
58966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58967       };
58968     }
58969   }
58970
58971   jresult = (void *)result;
58972   return jresult;
58973 }
58974
58975
58976 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_DroppedSignal(void * jarg1) {
58977   void * jresult ;
58978   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
58979   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
58980
58981   arg1 = (Dali::DragAndDropDetector *)jarg1;
58982   {
58983     try {
58984       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->DroppedSignal();
58985     } catch (std::out_of_range& e) {
58986       {
58987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58988       };
58989     } catch (std::exception& e) {
58990       {
58991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58992       };
58993     } catch (Dali::DaliException e) {
58994       {
58995         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58996       };
58997     } catch (...) {
58998       {
58999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59000       };
59001     }
59002   }
59003
59004   jresult = (void *)result;
59005   return jresult;
59006 }
59007
59008 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Empty(void * jarg1) {
59009   unsigned int jresult ;
59010   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
59011   bool result;
59012
59013   arg1 = (Dali::Signal< bool () > *)jarg1;
59014   {
59015     try {
59016       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Empty((Dali::Signal< bool () > const *)arg1);
59017     } catch (std::out_of_range& e) {
59018       {
59019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59020       };
59021     } catch (std::exception& e) {
59022       {
59023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59024       };
59025     } catch (Dali::DaliException e) {
59026       {
59027         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59028       };
59029     } catch (...) {
59030       {
59031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59032       };
59033     }
59034   }
59035
59036   jresult = result;
59037   return jresult;
59038 }
59039
59040
59041 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TimerSignalType_GetConnectionCount(void * jarg1) {
59042   unsigned long jresult ;
59043   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
59044   std::size_t result;
59045
59046   arg1 = (Dali::Signal< bool () > *)jarg1;
59047   {
59048     try {
59049       result = Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount((Dali::Signal< bool () > const *)arg1);
59050     } catch (std::out_of_range& e) {
59051       {
59052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59053       };
59054     } catch (std::exception& e) {
59055       {
59056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59057       };
59058     } catch (Dali::DaliException e) {
59059       {
59060         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59061       };
59062     } catch (...) {
59063       {
59064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59065       };
59066     }
59067   }
59068
59069   jresult = (unsigned long)result;
59070   return jresult;
59071 }
59072
59073
59074 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Connect(void * jarg1, void * jarg2) {
59075   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
59076   bool (*arg2)() = (bool (*)()) 0 ;
59077
59078   arg1 = (Dali::Signal< bool () > *)jarg1;
59079   arg2 = (bool (*)())jarg2;
59080   {
59081     try {
59082       Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(arg1,arg2);
59083     } catch (std::out_of_range& e) {
59084       {
59085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59086       };
59087     } catch (std::exception& e) {
59088       {
59089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59090       };
59091     } catch (Dali::DaliException e) {
59092       {
59093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59094       };
59095     } catch (...) {
59096       {
59097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59098       };
59099     }
59100   }
59101
59102 }
59103
59104
59105 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Disconnect(void * jarg1, void * jarg2) {
59106   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
59107   bool (*arg2)() = (bool (*)()) 0 ;
59108
59109   arg1 = (Dali::Signal< bool () > *)jarg1;
59110   arg2 = (bool (*)())jarg2;
59111   {
59112     try {
59113       Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(arg1,arg2);
59114     } catch (std::out_of_range& e) {
59115       {
59116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59117       };
59118     } catch (std::exception& e) {
59119       {
59120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59121       };
59122     } catch (Dali::DaliException e) {
59123       {
59124         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59125       };
59126     } catch (...) {
59127       {
59128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59129       };
59130     }
59131   }
59132
59133 }
59134
59135
59136 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Emit(void * jarg1) {
59137   unsigned int jresult ;
59138   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
59139   bool result;
59140
59141   arg1 = (Dali::Signal< bool () > *)jarg1;
59142   {
59143     try {
59144       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(arg1);
59145     } catch (std::out_of_range& e) {
59146       {
59147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59148       };
59149     } catch (std::exception& e) {
59150       {
59151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59152       };
59153     } catch (Dali::DaliException e) {
59154       {
59155         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59156       };
59157     } catch (...) {
59158       {
59159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59160       };
59161     }
59162   }
59163
59164   jresult = result;
59165   return jresult;
59166 }
59167
59168
59169 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimerSignalType() {
59170   void * jresult ;
59171   Dali::Signal< bool () > *result = 0 ;
59172
59173   {
59174     try {
59175       result = (Dali::Signal< bool () > *)new Dali::Signal< bool () >();
59176     } catch (std::out_of_range& e) {
59177       {
59178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59179       };
59180     } catch (std::exception& e) {
59181       {
59182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59183       };
59184     } catch (Dali::DaliException e) {
59185       {
59186         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59187       };
59188     } catch (...) {
59189       {
59190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59191       };
59192     }
59193   }
59194
59195   jresult = (void *)result;
59196   return jresult;
59197 }
59198
59199
59200 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimerSignalType(void * jarg1) {
59201   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
59202
59203   arg1 = (Dali::Signal< bool () > *)jarg1;
59204   {
59205     try {
59206       delete arg1;
59207     } catch (std::out_of_range& e) {
59208       {
59209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59210       };
59211     } catch (std::exception& e) {
59212       {
59213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59214       };
59215     } catch (Dali::DaliException e) {
59216       {
59217         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59218       };
59219     } catch (...) {
59220       {
59221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59222       };
59223     }
59224   }
59225
59226 }
59227
59228
59229 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_TYPE_get() {
59230   int jresult ;
59231   int result;
59232
59233   {
59234     try {
59235       result = (int)Dali::Toolkit::Visual::Property::TYPE;
59236     } catch (std::out_of_range& e) {
59237       {
59238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59239       };
59240     } catch (std::exception& e) {
59241       {
59242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59243       };
59244     } catch (Dali::DaliException e) {
59245       {
59246         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59247       };
59248     } catch (...) {
59249       {
59250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59251       };
59252     }
59253   }
59254
59255   jresult = (int)result;
59256   return jresult;
59257 }
59258
59259
59260 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_SHADER_get() {
59261   int jresult ;
59262   int result;
59263
59264   {
59265     try {
59266       result = (int)Dali::Toolkit::Visual::Property::SHADER;
59267     } catch (std::out_of_range& e) {
59268       {
59269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59270       };
59271     } catch (std::exception& e) {
59272       {
59273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59274       };
59275     } catch (Dali::DaliException e) {
59276       {
59277         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59278       };
59279     } catch (...) {
59280       {
59281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59282       };
59283     }
59284   }
59285
59286   jresult = (int)result;
59287   return jresult;
59288 }
59289
59290
59291 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_VERTEX_get() {
59292   int jresult ;
59293   int result;
59294
59295   {
59296     try {
59297       result = (int)Dali::Toolkit::Visual::Shader::Property::VERTEX_SHADER;
59298     } catch (std::out_of_range& e) {
59299       {
59300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59301       };
59302     } catch (std::exception& e) {
59303       {
59304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59305       };
59306     } catch (Dali::DaliException e) {
59307       {
59308         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59309       };
59310     } catch (...) {
59311       {
59312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59313       };
59314     }
59315   }
59316
59317   jresult = (int)result;
59318   return jresult;
59319 }
59320
59321
59322 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_FRAGMENT_get() {
59323   int jresult ;
59324   int result;
59325
59326   {
59327     try {
59328       result = (int)Dali::Toolkit::Visual::Shader::Property::FRAGMENT_SHADER;
59329     } catch (std::out_of_range& e) {
59330       {
59331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59332       };
59333     } catch (std::exception& e) {
59334       {
59335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59336       };
59337     } catch (Dali::DaliException e) {
59338       {
59339         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59340       };
59341     } catch (...) {
59342       {
59343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59344       };
59345     }
59346   }
59347
59348   jresult = (int)result;
59349   return jresult;
59350 }
59351
59352
59353 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_X_get() {
59354   int jresult ;
59355   int result;
59356
59357   {
59358     try {
59359       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_X;
59360     } catch (std::out_of_range& e) {
59361       {
59362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59363       };
59364     } catch (std::exception& e) {
59365       {
59366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59367       };
59368     } catch (Dali::DaliException e) {
59369       {
59370         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59371       };
59372     } catch (...) {
59373       {
59374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59375       };
59376     }
59377   }
59378
59379   jresult = (int)result;
59380   return jresult;
59381 }
59382
59383
59384 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_Y_get() {
59385   int jresult ;
59386   int result;
59387
59388   {
59389     try {
59390       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_Y;
59391     } catch (std::out_of_range& e) {
59392       {
59393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59394       };
59395     } catch (std::exception& e) {
59396       {
59397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59398       };
59399     } catch (Dali::DaliException e) {
59400       {
59401         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59402       };
59403     } catch (...) {
59404       {
59405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59406       };
59407     }
59408   }
59409
59410   jresult = (int)result;
59411   return jresult;
59412 }
59413
59414
59415 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_HINTS_get() {
59416   int jresult ;
59417   int result;
59418
59419   {
59420     try {
59421       result = (int)Dali::Toolkit::Visual::Shader::Property::HINTS;
59422     } catch (std::out_of_range& e) {
59423       {
59424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59425       };
59426     } catch (std::exception& e) {
59427       {
59428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59429       };
59430     } catch (Dali::DaliException e) {
59431       {
59432         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59433       };
59434     } catch (...) {
59435       {
59436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59437       };
59438     }
59439   }
59440
59441   jresult = (int)result;
59442   return jresult;
59443 }
59444
59445
59446 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_COLOR_get() {
59447   int jresult ;
59448   int result;
59449
59450   {
59451     try {
59452       result = (int)Dali::Toolkit::BorderVisual::Property::COLOR;
59453     } catch (std::out_of_range& e) {
59454       {
59455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59456       };
59457     } catch (std::exception& e) {
59458       {
59459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59460       };
59461     } catch (Dali::DaliException e) {
59462       {
59463         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59464       };
59465     } catch (...) {
59466       {
59467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59468       };
59469     }
59470   }
59471
59472   jresult = (int)result;
59473   return jresult;
59474 }
59475
59476
59477 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_SIZE_get() {
59478   int jresult ;
59479   int result;
59480
59481   {
59482     try {
59483       result = (int)Dali::Toolkit::BorderVisual::Property::SIZE;
59484     } catch (std::out_of_range& e) {
59485       {
59486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59487       };
59488     } catch (std::exception& e) {
59489       {
59490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59491       };
59492     } catch (Dali::DaliException e) {
59493       {
59494         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59495       };
59496     } catch (...) {
59497       {
59498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59499       };
59500     }
59501   }
59502
59503   jresult = (int)result;
59504   return jresult;
59505 }
59506
59507
59508 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_ANTI_ALIASING_get() {
59509   int jresult ;
59510   int result;
59511
59512   {
59513     try {
59514       result = (int)Dali::Toolkit::BorderVisual::Property::ANTI_ALIASING;
59515     } catch (std::out_of_range& e) {
59516       {
59517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59518       };
59519     } catch (std::exception& e) {
59520       {
59521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59522       };
59523     } catch (Dali::DaliException e) {
59524       {
59525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59526       };
59527     } catch (...) {
59528       {
59529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59530       };
59531     }
59532   }
59533
59534   jresult = (int)result;
59535   return jresult;
59536 }
59537
59538
59539 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_COLOR_VISUAL_MIX_COLOR_get() {
59540   int jresult ;
59541   int result;
59542
59543   {
59544     try {
59545       result = (int)Dali::Toolkit::ColorVisual::Property::MIX_COLOR;
59546     } catch (std::out_of_range& e) {
59547       {
59548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59549       };
59550     } catch (std::exception& e) {
59551       {
59552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59553       };
59554     } catch (Dali::DaliException e) {
59555       {
59556         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59557       };
59558     } catch (...) {
59559       {
59560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59561       };
59562     }
59563   }
59564
59565   jresult = (int)result;
59566   return jresult;
59567 }
59568
59569
59570 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_START_POSITION_get() {
59571   int jresult ;
59572   int result;
59573
59574   {
59575     try {
59576       result = (int)Dali::Toolkit::GradientVisual::Property::START_POSITION;
59577     } catch (std::out_of_range& e) {
59578       {
59579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59580       };
59581     } catch (std::exception& e) {
59582       {
59583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59584       };
59585     } catch (Dali::DaliException e) {
59586       {
59587         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59588       };
59589     } catch (...) {
59590       {
59591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59592       };
59593     }
59594   }
59595
59596   jresult = (int)result;
59597   return jresult;
59598 }
59599
59600
59601 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_END_POSITION_get() {
59602   int jresult ;
59603   int result;
59604
59605   {
59606     try {
59607       result = (int)Dali::Toolkit::GradientVisual::Property::END_POSITION;
59608     } catch (std::out_of_range& e) {
59609       {
59610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59611       };
59612     } catch (std::exception& e) {
59613       {
59614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59615       };
59616     } catch (Dali::DaliException e) {
59617       {
59618         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59619       };
59620     } catch (...) {
59621       {
59622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59623       };
59624     }
59625   }
59626
59627   jresult = (int)result;
59628   return jresult;
59629 }
59630
59631
59632 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_CENTER_get() {
59633   int jresult ;
59634   int result;
59635
59636   {
59637     try {
59638       result = (int)Dali::Toolkit::GradientVisual::Property::CENTER;
59639     } catch (std::out_of_range& e) {
59640       {
59641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59642       };
59643     } catch (std::exception& e) {
59644       {
59645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59646       };
59647     } catch (Dali::DaliException e) {
59648       {
59649         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59650       };
59651     } catch (...) {
59652       {
59653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59654       };
59655     }
59656   }
59657
59658   jresult = (int)result;
59659   return jresult;
59660 }
59661
59662
59663 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_RADIUS_get() {
59664   int jresult ;
59665   int result;
59666
59667   {
59668     try {
59669       result = (int)Dali::Toolkit::GradientVisual::Property::RADIUS;
59670     } catch (std::out_of_range& e) {
59671       {
59672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59673       };
59674     } catch (std::exception& e) {
59675       {
59676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59677       };
59678     } catch (Dali::DaliException e) {
59679       {
59680         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59681       };
59682     } catch (...) {
59683       {
59684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59685       };
59686     }
59687   }
59688
59689   jresult = (int)result;
59690   return jresult;
59691 }
59692
59693
59694 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_OFFSET_get() {
59695   int jresult ;
59696   int result;
59697
59698   {
59699     try {
59700       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_OFFSET;
59701     } catch (std::out_of_range& e) {
59702       {
59703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59704       };
59705     } catch (std::exception& e) {
59706       {
59707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59708       };
59709     } catch (Dali::DaliException e) {
59710       {
59711         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59712       };
59713     } catch (...) {
59714       {
59715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59716       };
59717     }
59718   }
59719
59720   jresult = (int)result;
59721   return jresult;
59722 }
59723
59724
59725 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_COLOR_get() {
59726   int jresult ;
59727   int result;
59728
59729   {
59730     try {
59731       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_COLOR;
59732     } catch (std::out_of_range& e) {
59733       {
59734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59735       };
59736     } catch (std::exception& e) {
59737       {
59738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59739       };
59740     } catch (Dali::DaliException e) {
59741       {
59742         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59743       };
59744     } catch (...) {
59745       {
59746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59747       };
59748     }
59749   }
59750
59751   jresult = (int)result;
59752   return jresult;
59753 }
59754
59755
59756 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_UNITS_get() {
59757   int jresult ;
59758   int result;
59759
59760   {
59761     try {
59762       result = (int)Dali::Toolkit::GradientVisual::Property::UNITS;
59763     } catch (std::out_of_range& e) {
59764       {
59765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59766       };
59767     } catch (std::exception& e) {
59768       {
59769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59770       };
59771     } catch (Dali::DaliException e) {
59772       {
59773         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59774       };
59775     } catch (...) {
59776       {
59777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59778       };
59779     }
59780   }
59781
59782   jresult = (int)result;
59783   return jresult;
59784 }
59785
59786
59787 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_SPREAD_METHOD_get() {
59788   int jresult ;
59789   int result;
59790
59791   {
59792     try {
59793       result = (int)Dali::Toolkit::GradientVisual::Property::SPREAD_METHOD;
59794     } catch (std::out_of_range& e) {
59795       {
59796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59797       };
59798     } catch (std::exception& e) {
59799       {
59800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59801       };
59802     } catch (Dali::DaliException e) {
59803       {
59804         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59805       };
59806     } catch (...) {
59807       {
59808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59809       };
59810     }
59811   }
59812
59813   jresult = (int)result;
59814   return jresult;
59815 }
59816
59817
59818 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_URL_get() {
59819   int jresult ;
59820   int result;
59821
59822   {
59823     try {
59824       result = (int)Dali::Toolkit::ImageVisual::Property::URL;
59825     } catch (std::out_of_range& e) {
59826       {
59827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59828       };
59829     } catch (std::exception& e) {
59830       {
59831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59832       };
59833     } catch (Dali::DaliException e) {
59834       {
59835         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59836       };
59837     } catch (...) {
59838       {
59839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59840       };
59841     }
59842   }
59843
59844   jresult = (int)result;
59845   return jresult;
59846 }
59847
59848 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ALPHA_MASK_URL_get() {
59849   int jresult ;
59850   int result;
59851
59852   {
59853     try {
59854       result = (int)Dali::Toolkit::ImageVisual::Property::ALPHA_MASK_URL;
59855     } catch (std::out_of_range& e) {
59856       {
59857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59858       };
59859     } catch (std::exception& e) {
59860       {
59861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59862       };
59863     } catch (Dali::DaliException e) {
59864       {
59865         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59866       };
59867     } catch (...) {
59868       {
59869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59870       };
59871     }
59872   }
59873
59874   jresult = (int)result;
59875   return jresult;
59876 }
59877
59878
59879 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BATCH_SIZE_get() {
59880   int jresult ;
59881   int result;
59882   {
59883     try
59884     {
59885       result = (int)Dali::Toolkit::ImageVisual::Property::BATCH_SIZE;
59886     } catch (std::out_of_range& e) {
59887       {
59888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59889       };
59890     } catch (std::exception& e) {
59891       {
59892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59893       };
59894     } catch (Dali::DaliException e) {
59895       {
59896         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59897       };
59898     } catch (...) {
59899       {
59900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59901       };
59902     }
59903   }
59904
59905   jresult = (int)result;
59906   return jresult;
59907 }
59908
59909 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CACHE_SIZE_get() {
59910   int jresult ;
59911   int result;
59912   {
59913     try
59914     {
59915       result = (int)Dali::Toolkit::ImageVisual::Property::CACHE_SIZE;
59916     } catch (std::out_of_range& e) {
59917       {
59918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59919       };
59920     } catch (std::exception& e) {
59921       {
59922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59923       };
59924     } catch (Dali::DaliException e) {
59925       {
59926         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59927       };
59928     } catch (...) {
59929       {
59930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59931       };
59932     }
59933   }
59934
59935   jresult = (int)result;
59936   return jresult;
59937 }
59938
59939 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FRAME_DELAY_get() {
59940   int jresult ;
59941   int result;
59942   {
59943     try
59944     {
59945       result = (int)Dali::Toolkit::ImageVisual::Property::FRAME_DELAY;
59946     } catch (std::out_of_range& e) {
59947       {
59948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59949       };
59950     } catch (std::exception& e) {
59951       {
59952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59953       };
59954     } catch (Dali::DaliException e) {
59955       {
59956         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59957       };
59958     } catch (...) {
59959       {
59960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59961       };
59962     }
59963   }
59964
59965   jresult = (int)result;
59966   return jresult;
59967 }
59968
59969 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_LOOP_COUNT_get() {
59970   return (int)Dali::Toolkit::DevelImageVisual::Property::LOOP_COUNT;
59971 }
59972
59973 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_MASK_CONTENT_SCALE_get() {
59974   int jresult ;
59975   int result;
59976   {
59977     try
59978     {
59979       result = (int)Dali::Toolkit::ImageVisual::Property::MASK_CONTENT_SCALE;
59980     } catch (std::out_of_range& e) {
59981       {
59982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59983       };
59984     } catch (std::exception& e) {
59985       {
59986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59987       };
59988     } catch (Dali::DaliException e) {
59989       {
59990         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59991       };
59992     } catch (...) {
59993       {
59994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59995       };
59996     }
59997   }
59998
59999   jresult = (int)result;
60000   return jresult;
60001 }
60002
60003 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CROP_TO_MASK_get() {
60004   int jresult ;
60005   int result;
60006   {
60007     try
60008     {
60009       result = (int)Dali::Toolkit::ImageVisual::Property::CROP_TO_MASK;
60010     } catch (std::out_of_range& e) {
60011       {
60012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60013       };
60014     } catch (std::exception& e) {
60015       {
60016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60017       };
60018     } catch (Dali::DaliException e) {
60019       {
60020         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60021       };
60022     } catch (...) {
60023       {
60024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60025       };
60026     }
60027   }
60028
60029   jresult = (int)result;
60030   return jresult;
60031 }
60032
60033 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FITTING_MODE_get() {
60034   int jresult ;
60035   int result;
60036
60037   {
60038     try {
60039       result = (int)Dali::Toolkit::ImageVisual::Property::FITTING_MODE;
60040     } catch (std::out_of_range& e) {
60041       {
60042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60043       };
60044     } catch (std::exception& e) {
60045       {
60046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60047       };
60048     } catch (Dali::DaliException e) {
60049       {
60050         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60051       };
60052     } catch (...) {
60053       {
60054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60055       };
60056     }
60057   }
60058
60059   jresult = (int)result;
60060   return jresult;
60061 }
60062
60063
60064 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SAMPLING_MODE_get() {
60065   int jresult ;
60066   int result;
60067
60068   {
60069     try {
60070       result = (int)Dali::Toolkit::ImageVisual::Property::SAMPLING_MODE;
60071     } catch (std::out_of_range& e) {
60072       {
60073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60074       };
60075     } catch (std::exception& e) {
60076       {
60077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60078       };
60079     } catch (Dali::DaliException e) {
60080       {
60081         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60082       };
60083     } catch (...) {
60084       {
60085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60086       };
60087     }
60088   }
60089
60090   jresult = (int)result;
60091   return jresult;
60092 }
60093
60094 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_RELEASE_POLICY_get() {
60095   int jresult ;
60096   int result;
60097   {
60098     try
60099     {
60100       result = (int)Dali::Toolkit::ImageVisual::Property::RELEASE_POLICY;
60101     } catch (std::out_of_range& e) {
60102       {
60103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60104       };
60105     } catch (std::exception& e) {
60106       {
60107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60108       };
60109     } catch (...) {
60110       {
60111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60112       };
60113     }
60114   }
60115   jresult = (int)result;
60116   return jresult;
60117 }
60118
60119 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_LOAD_POLICY_get() {
60120   int jresult ;
60121   int result;
60122   {
60123     try
60124     {
60125       result = (int)Dali::Toolkit::ImageVisual::Property::LOAD_POLICY;
60126     } catch (std::out_of_range& e) {
60127       {
60128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60129       };
60130     } catch (std::exception& e) {
60131       {
60132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60133       };
60134     } catch (...) {
60135       {
60136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60137       };
60138     }
60139   }
60140   jresult = (int)result;
60141   return jresult;
60142 }
60143
60144 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ORIENTATION_CORRECTION_get() {
60145   int jresult ;
60146   int result;
60147   {
60148     try
60149     {
60150       result = (int)Dali::Toolkit::ImageVisual::Property::ORIENTATION_CORRECTION;
60151     } catch (std::out_of_range& e) {
60152       {
60153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60154       };
60155     } catch (std::exception& e) {
60156       {
60157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60158       };
60159     } catch (...) {
60160       {
60161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60162       };
60163     }
60164   }
60165   jresult = (int)result;
60166   return jresult;
60167 }
60168
60169
60170 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_AUXILIARY_IMAGE_URL_get() {
60171   int jresult ;
60172   int result;
60173   {
60174     try
60175     {
60176       result = (int)Dali::Toolkit::DevelImageVisual::Property::AUXILIARY_IMAGE;
60177     } catch (std::out_of_range& e) {
60178       {
60179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60180       };
60181     } catch (std::exception& e) {
60182       {
60183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60184       };
60185     } catch (...) {
60186       {
60187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60188       };
60189     }
60190   }
60191   jresult = (int)result;
60192   return jresult;
60193 }
60194
60195 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_AUXILIARY_IMAGE_ALPHA_get() {
60196   int jresult ;
60197   int result;
60198   {
60199     try
60200     {
60201       result = (int)Dali::Toolkit::DevelImageVisual::Property::AUXILIARY_IMAGE_ALPHA;
60202     } catch (std::out_of_range& e) {
60203       {
60204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60205       };
60206     } catch (std::exception& e) {
60207       {
60208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60209       };
60210     } catch (...) {
60211       {
60212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60213       };
60214     }
60215   }
60216   jresult = (int)result;
60217   return jresult;
60218 }
60219
60220
60221
60222 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_WIDTH_get() {
60223   int jresult ;
60224   int result;
60225
60226   {
60227     try {
60228       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_WIDTH;
60229     } catch (std::out_of_range& e) {
60230       {
60231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60232       };
60233     } catch (std::exception& e) {
60234       {
60235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60236       };
60237     } catch (Dali::DaliException e) {
60238       {
60239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60240       };
60241     } catch (...) {
60242       {
60243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60244       };
60245     }
60246   }
60247
60248   jresult = (int)result;
60249   return jresult;
60250 }
60251
60252
60253 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_HEIGHT_get() {
60254   int jresult ;
60255   int result;
60256
60257   {
60258     try {
60259       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_HEIGHT;
60260     } catch (std::out_of_range& e) {
60261       {
60262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60263       };
60264     } catch (std::exception& e) {
60265       {
60266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60267       };
60268     } catch (Dali::DaliException e) {
60269       {
60270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60271       };
60272     } catch (...) {
60273       {
60274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60275       };
60276     }
60277   }
60278
60279   jresult = (int)result;
60280   return jresult;
60281 }
60282
60283
60284 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SYNCHRONOUS_LOADING_get() {
60285   int jresult ;
60286   int result;
60287
60288   {
60289     try {
60290       result = (int)Dali::Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING;
60291     } catch (std::out_of_range& e) {
60292       {
60293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60294       };
60295     } catch (std::exception& e) {
60296       {
60297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60298       };
60299     } catch (Dali::DaliException e) {
60300       {
60301         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60302       };
60303     } catch (...) {
60304       {
60305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60306       };
60307     }
60308   }
60309
60310   jresult = (int)result;
60311   return jresult;
60312 }
60313
60314
60315 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BORDER_ONLY_get() {
60316   int jresult ;
60317   int result;
60318
60319   {
60320     try {
60321       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER_ONLY;
60322     } catch (std::out_of_range& e) {
60323       {
60324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60325       };
60326     } catch (std::exception& e) {
60327       {
60328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60329       };
60330     } catch (Dali::DaliException e) {
60331       {
60332         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60333       };
60334     } catch (...) {
60335       {
60336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60337       };
60338     }
60339   }
60340
60341   jresult = (int)result;
60342   return jresult;
60343 }
60344
60345
60346 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_PIXEL_AREA_get() {
60347   int jresult ;
60348   int result;
60349
60350   {
60351     try {
60352       result = (int)Dali::Toolkit::ImageVisual::Property::PIXEL_AREA;
60353     } catch (std::out_of_range& e) {
60354       {
60355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60356       };
60357     } catch (std::exception& e) {
60358       {
60359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60360       };
60361     } catch (Dali::DaliException e) {
60362       {
60363         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60364       };
60365     } catch (...) {
60366       {
60367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60368       };
60369     }
60370   }
60371
60372   jresult = (int)result;
60373   return jresult;
60374 }
60375
60376
60377 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_U_get() {
60378   int jresult ;
60379   int result;
60380
60381   {
60382     try {
60383       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_U;
60384     } catch (std::out_of_range& e) {
60385       {
60386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60387       };
60388     } catch (std::exception& e) {
60389       {
60390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60391       };
60392     } catch (Dali::DaliException e) {
60393       {
60394         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60395       };
60396     } catch (...) {
60397       {
60398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60399       };
60400     }
60401   }
60402
60403   jresult = (int)result;
60404   return jresult;
60405 }
60406
60407
60408 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_V_get() {
60409   int jresult ;
60410   int result;
60411
60412   {
60413     try {
60414       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_V;
60415     } catch (std::out_of_range& e) {
60416       {
60417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60418       };
60419     } catch (std::exception& e) {
60420       {
60421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60422       };
60423     } catch (Dali::DaliException e) {
60424       {
60425         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60426       };
60427     } catch (...) {
60428       {
60429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60430       };
60431     }
60432   }
60433
60434   jresult = (int)result;
60435   return jresult;
60436 }
60437
60438 SWIGEXPORT int SWIGSTDCALL CSharp_Image_Visual_BORDER_get() {
60439   int jresult ;
60440   int result;
60441
60442   {
60443     try {
60444       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER;
60445     } catch (std::out_of_range& e) {
60446       {
60447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60448       };
60449     } catch (std::exception& e) {
60450       {
60451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60452       };
60453     } catch (...) {
60454       {
60455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60456       };
60457     }
60458   }
60459   jresult = (int)result;
60460   return jresult;
60461 }
60462
60463 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_OBJECT_URL_get() {
60464   int jresult ;
60465   int result;
60466
60467   {
60468     try {
60469       result = (int)Dali::Toolkit::MeshVisual::Property::OBJECT_URL;
60470     } catch (std::out_of_range& e) {
60471       {
60472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60473       };
60474     } catch (std::exception& e) {
60475       {
60476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60477       };
60478     } catch (Dali::DaliException e) {
60479       {
60480         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60481       };
60482     } catch (...) {
60483       {
60484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60485       };
60486     }
60487   }
60488
60489   jresult = (int)result;
60490   return jresult;
60491 }
60492
60493
60494 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_MATERIAL_URL_get() {
60495   int jresult ;
60496   int result;
60497
60498   {
60499     try {
60500       result = (int)Dali::Toolkit::MeshVisual::Property::MATERIAL_URL;
60501     } catch (std::out_of_range& e) {
60502       {
60503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60504       };
60505     } catch (std::exception& e) {
60506       {
60507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60508       };
60509     } catch (Dali::DaliException e) {
60510       {
60511         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60512       };
60513     } catch (...) {
60514       {
60515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60516       };
60517     }
60518   }
60519
60520   jresult = (int)result;
60521   return jresult;
60522 }
60523
60524
60525 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_TEXTURES_PATH_get() {
60526   int jresult ;
60527   int result;
60528
60529   {
60530     try {
60531       result = (int)Dali::Toolkit::MeshVisual::Property::TEXTURES_PATH;
60532     } catch (std::out_of_range& e) {
60533       {
60534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60535       };
60536     } catch (std::exception& e) {
60537       {
60538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60539       };
60540     } catch (Dali::DaliException e) {
60541       {
60542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60543       };
60544     } catch (...) {
60545       {
60546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60547       };
60548     }
60549   }
60550
60551   jresult = (int)result;
60552   return jresult;
60553 }
60554
60555
60556 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_SHADING_MODE_get() {
60557   int jresult ;
60558   int result;
60559
60560   {
60561     try {
60562       result = (int)Dali::Toolkit::MeshVisual::Property::SHADING_MODE;
60563     } catch (std::out_of_range& e) {
60564       {
60565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60566       };
60567     } catch (std::exception& e) {
60568       {
60569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60570       };
60571     } catch (Dali::DaliException e) {
60572       {
60573         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60574       };
60575     } catch (...) {
60576       {
60577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60578       };
60579     }
60580   }
60581
60582   jresult = (int)result;
60583   return jresult;
60584 }
60585
60586
60587 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_MIPMAPPING_get() {
60588   int jresult ;
60589   int result;
60590
60591   {
60592     try {
60593       result = (int)Dali::Toolkit::MeshVisual::Property::USE_MIPMAPPING;
60594     } catch (std::out_of_range& e) {
60595       {
60596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60597       };
60598     } catch (std::exception& e) {
60599       {
60600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60601       };
60602     } catch (Dali::DaliException e) {
60603       {
60604         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60605       };
60606     } catch (...) {
60607       {
60608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60609       };
60610     }
60611   }
60612
60613   jresult = (int)result;
60614   return jresult;
60615 }
60616
60617
60618 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_SOFT_NORMALS_get() {
60619   int jresult ;
60620   int result;
60621
60622   {
60623     try {
60624       result = (int)Dali::Toolkit::MeshVisual::Property::USE_SOFT_NORMALS;
60625     } catch (std::out_of_range& e) {
60626       {
60627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60628       };
60629     } catch (std::exception& e) {
60630       {
60631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60632       };
60633     } catch (Dali::DaliException e) {
60634       {
60635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60636       };
60637     } catch (...) {
60638       {
60639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60640       };
60641     }
60642   }
60643
60644   jresult = (int)result;
60645   return jresult;
60646 }
60647
60648
60649 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_LIGHT_POSITION_get() {
60650   int jresult ;
60651   int result;
60652
60653   {
60654     try {
60655       result = (int)Dali::Toolkit::MeshVisual::Property::LIGHT_POSITION;
60656     } catch (std::out_of_range& e) {
60657       {
60658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60659       };
60660     } catch (std::exception& e) {
60661       {
60662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60663       };
60664     } catch (Dali::DaliException e) {
60665       {
60666         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60667       };
60668     } catch (...) {
60669       {
60670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60671       };
60672     }
60673   }
60674
60675   jresult = (int)result;
60676   return jresult;
60677 }
60678
60679
60680 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SHAPE_get() {
60681   int jresult ;
60682   int result;
60683
60684   {
60685     try {
60686       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SHAPE;
60687     } catch (std::out_of_range& e) {
60688       {
60689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60690       };
60691     } catch (std::exception& e) {
60692       {
60693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60694       };
60695     } catch (Dali::DaliException e) {
60696       {
60697         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60698       };
60699     } catch (...) {
60700       {
60701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60702       };
60703     }
60704   }
60705
60706   jresult = (int)result;
60707   return jresult;
60708 }
60709
60710
60711 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_MIX_COLOR_get() {
60712   int jresult ;
60713   int result;
60714
60715   {
60716     try {
60717       result = (int)Dali::Toolkit::PrimitiveVisual::Property::MIX_COLOR;
60718     } catch (std::out_of_range& e) {
60719       {
60720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60721       };
60722     } catch (std::exception& e) {
60723       {
60724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60725       };
60726     } catch (Dali::DaliException e) {
60727       {
60728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60729       };
60730     } catch (...) {
60731       {
60732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60733       };
60734     }
60735   }
60736
60737   jresult = (int)result;
60738   return jresult;
60739 }
60740
60741
60742 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SLICES_get() {
60743   int jresult ;
60744   int result;
60745
60746   {
60747     try {
60748       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SLICES;
60749     } catch (std::out_of_range& e) {
60750       {
60751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60752       };
60753     } catch (std::exception& e) {
60754       {
60755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60756       };
60757     } catch (Dali::DaliException e) {
60758       {
60759         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60760       };
60761     } catch (...) {
60762       {
60763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60764       };
60765     }
60766   }
60767
60768   jresult = (int)result;
60769   return jresult;
60770 }
60771
60772
60773 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_STACKS_get() {
60774   int jresult ;
60775   int result;
60776
60777   {
60778     try {
60779       result = (int)Dali::Toolkit::PrimitiveVisual::Property::STACKS;
60780     } catch (std::out_of_range& e) {
60781       {
60782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60783       };
60784     } catch (std::exception& e) {
60785       {
60786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60787       };
60788     } catch (Dali::DaliException e) {
60789       {
60790         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60791       };
60792     } catch (...) {
60793       {
60794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60795       };
60796     }
60797   }
60798
60799   jresult = (int)result;
60800   return jresult;
60801 }
60802
60803
60804 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_TOP_RADIUS_get() {
60805   int jresult ;
60806   int result;
60807
60808   {
60809     try {
60810       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_TOP_RADIUS;
60811     } catch (std::out_of_range& e) {
60812       {
60813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60814       };
60815     } catch (std::exception& e) {
60816       {
60817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60818       };
60819     } catch (Dali::DaliException e) {
60820       {
60821         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60822       };
60823     } catch (...) {
60824       {
60825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60826       };
60827     }
60828   }
60829
60830   jresult = (int)result;
60831   return jresult;
60832 }
60833
60834
60835 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_BOTTOM_RADIUS_get() {
60836   int jresult ;
60837   int result;
60838
60839   {
60840     try {
60841       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS;
60842     } catch (std::out_of_range& e) {
60843       {
60844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60845       };
60846     } catch (std::exception& e) {
60847       {
60848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60849       };
60850     } catch (Dali::DaliException e) {
60851       {
60852         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60853       };
60854     } catch (...) {
60855       {
60856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60857       };
60858     }
60859   }
60860
60861   jresult = (int)result;
60862   return jresult;
60863 }
60864
60865
60866 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_HEIGHT_get() {
60867   int jresult ;
60868   int result;
60869
60870   {
60871     try {
60872       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_HEIGHT;
60873     } catch (std::out_of_range& e) {
60874       {
60875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60876       };
60877     } catch (std::exception& e) {
60878       {
60879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60880       };
60881     } catch (Dali::DaliException e) {
60882       {
60883         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60884       };
60885     } catch (...) {
60886       {
60887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60888       };
60889     }
60890   }
60891
60892   jresult = (int)result;
60893   return jresult;
60894 }
60895
60896
60897 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_RADIUS_get() {
60898   int jresult ;
60899   int result;
60900
60901   {
60902     try {
60903       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_RADIUS;
60904     } catch (std::out_of_range& e) {
60905       {
60906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60907       };
60908     } catch (std::exception& e) {
60909       {
60910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60911       };
60912     } catch (Dali::DaliException e) {
60913       {
60914         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60915       };
60916     } catch (...) {
60917       {
60918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60919       };
60920     }
60921   }
60922
60923   jresult = (int)result;
60924   return jresult;
60925 }
60926
60927
60928 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_DIMENSIONS_get() {
60929   int jresult ;
60930   int result;
60931
60932   {
60933     try {
60934       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_DIMENSIONS;
60935     } catch (std::out_of_range& e) {
60936       {
60937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60938       };
60939     } catch (std::exception& e) {
60940       {
60941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60942       };
60943     } catch (Dali::DaliException e) {
60944       {
60945         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60946       };
60947     } catch (...) {
60948       {
60949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60950       };
60951     }
60952   }
60953
60954   jresult = (int)result;
60955   return jresult;
60956 }
60957
60958
60959 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_PERCENTAGE_get() {
60960   int jresult ;
60961   int result;
60962
60963   {
60964     try {
60965       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_PERCENTAGE;
60966     } catch (std::out_of_range& e) {
60967       {
60968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60969       };
60970     } catch (std::exception& e) {
60971       {
60972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60973       };
60974     } catch (Dali::DaliException e) {
60975       {
60976         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60977       };
60978     } catch (...) {
60979       {
60980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60981       };
60982     }
60983   }
60984
60985   jresult = (int)result;
60986   return jresult;
60987 }
60988
60989
60990 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_SMOOTHNESS_get() {
60991   int jresult ;
60992   int result;
60993
60994   {
60995     try {
60996       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_SMOOTHNESS;
60997     } catch (std::out_of_range& e) {
60998       {
60999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61000       };
61001     } catch (std::exception& e) {
61002       {
61003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61004       };
61005     } catch (Dali::DaliException e) {
61006       {
61007         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61008       };
61009     } catch (...) {
61010       {
61011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61012       };
61013     }
61014   }
61015
61016   jresult = (int)result;
61017   return jresult;
61018 }
61019
61020
61021 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_LIGHT_POSITION_get() {
61022   int jresult ;
61023   int result;
61024
61025   {
61026     try {
61027       result = (int)Dali::Toolkit::PrimitiveVisual::Property::LIGHT_POSITION;
61028     } catch (std::out_of_range& e) {
61029       {
61030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61031       };
61032     } catch (std::exception& e) {
61033       {
61034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61035       };
61036     } catch (Dali::DaliException e) {
61037       {
61038         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61039       };
61040     } catch (...) {
61041       {
61042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61043       };
61044     }
61045   }
61046
61047   jresult = (int)result;
61048   return jresult;
61049 }
61050
61051
61052 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_get() {
61053   int jresult ;
61054   int result;
61055
61056   {
61057     try {
61058       result = (int)Dali::Toolkit::TextVisual::Property::TEXT;
61059     } catch (std::out_of_range& e) {
61060       {
61061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61062       };
61063     } catch (std::exception& e) {
61064       {
61065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61066       };
61067     } catch (Dali::DaliException e) {
61068       {
61069         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61070       };
61071     } catch (...) {
61072       {
61073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61074       };
61075     }
61076   }
61077
61078   jresult = (int)result;
61079   return jresult;
61080 }
61081
61082
61083 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_FAMILY_get() {
61084   int jresult ;
61085   int result;
61086
61087   {
61088     try {
61089       result = (int)Dali::Toolkit::TextVisual::Property::FONT_FAMILY;
61090     } catch (std::out_of_range& e) {
61091       {
61092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61093       };
61094     } catch (std::exception& e) {
61095       {
61096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61097       };
61098     } catch (Dali::DaliException e) {
61099       {
61100         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61101       };
61102     } catch (...) {
61103       {
61104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61105       };
61106     }
61107   }
61108
61109   jresult = (int)result;
61110   return jresult;
61111 }
61112
61113
61114 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_STYLE_get() {
61115   int jresult ;
61116   int result;
61117
61118   {
61119     try {
61120       result = (int)Dali::Toolkit::TextVisual::Property::FONT_STYLE;
61121     } catch (std::out_of_range& e) {
61122       {
61123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61124       };
61125     } catch (std::exception& e) {
61126       {
61127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61128       };
61129     } catch (Dali::DaliException e) {
61130       {
61131         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61132       };
61133     } catch (...) {
61134       {
61135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61136       };
61137     }
61138   }
61139
61140   jresult = (int)result;
61141   return jresult;
61142 }
61143
61144
61145 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_POINT_SIZE_get() {
61146   int jresult ;
61147   int result;
61148
61149   {
61150     try {
61151       result = (int)Dali::Toolkit::TextVisual::Property::POINT_SIZE;
61152     } catch (std::out_of_range& e) {
61153       {
61154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61155       };
61156     } catch (std::exception& e) {
61157       {
61158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61159       };
61160     } catch (Dali::DaliException e) {
61161       {
61162         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61163       };
61164     } catch (...) {
61165       {
61166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61167       };
61168     }
61169   }
61170
61171   jresult = (int)result;
61172   return jresult;
61173 }
61174
61175
61176 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_MULTI_LINE_get() {
61177   int jresult ;
61178   int result;
61179
61180   {
61181     try {
61182       result = (int)Dali::Toolkit::TextVisual::Property::MULTI_LINE;
61183     } catch (std::out_of_range& e) {
61184       {
61185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61186       };
61187     } catch (std::exception& e) {
61188       {
61189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61190       };
61191     } catch (Dali::DaliException e) {
61192       {
61193         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61194       };
61195     } catch (...) {
61196       {
61197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61198       };
61199     }
61200   }
61201
61202   jresult = (int)result;
61203   return jresult;
61204 }
61205
61206
61207 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_HORIZONTAL_ALIGNMENT_get() {
61208   int jresult ;
61209   int result;
61210
61211   {
61212     try {
61213       result = (int)Dali::Toolkit::TextVisual::Property::HORIZONTAL_ALIGNMENT;
61214     } catch (std::out_of_range& e) {
61215       {
61216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61217       };
61218     } catch (std::exception& e) {
61219       {
61220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61221       };
61222     } catch (Dali::DaliException e) {
61223       {
61224         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61225       };
61226     } catch (...) {
61227       {
61228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61229       };
61230     }
61231   }
61232
61233   jresult = (int)result;
61234   return jresult;
61235 }
61236
61237
61238 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_VERTICAL_ALIGNMENT_get() {
61239   int jresult ;
61240   int result;
61241
61242   {
61243     try {
61244       result = (int)Dali::Toolkit::TextVisual::Property::VERTICAL_ALIGNMENT;
61245     } catch (std::out_of_range& e) {
61246       {
61247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61248       };
61249     } catch (std::exception& e) {
61250       {
61251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61252       };
61253     } catch (Dali::DaliException e) {
61254       {
61255         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61256       };
61257     } catch (...) {
61258       {
61259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61260       };
61261     }
61262   }
61263
61264   jresult = (int)result;
61265   return jresult;
61266 }
61267
61268
61269 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_COLOR_get() {
61270   int jresult ;
61271   int result;
61272
61273   {
61274     try {
61275       result = (int)Dali::Toolkit::TextVisual::Property::TEXT_COLOR;
61276     } catch (std::out_of_range& e) {
61277       {
61278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61279       };
61280     } catch (std::exception& e) {
61281       {
61282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61283       };
61284     } catch (Dali::DaliException e) {
61285       {
61286         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61287       };
61288     } catch (...) {
61289       {
61290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61291       };
61292     }
61293   }
61294
61295   jresult = (int)result;
61296   return jresult;
61297 }
61298
61299
61300 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_ENABLE_MARKUP_get() {
61301   int jresult ;
61302   int result;
61303
61304   {
61305     try {
61306       result = (int)Dali::Toolkit::TextVisual::Property::ENABLE_MARKUP;
61307     } catch (std::out_of_range& e) {
61308       {
61309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61310       };
61311     } catch (std::exception& e) {
61312       {
61313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61314       };
61315     } catch (Dali::DaliException e) {
61316       {
61317         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61318       };
61319     } catch (...) {
61320       {
61321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61322       };
61323     }
61324   }
61325
61326   jresult = (int)result;
61327   return jresult;
61328 }
61329
61330
61331 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Builder() {
61332   void * jresult ;
61333   Dali::Toolkit::Builder *result = 0 ;
61334
61335   {
61336     try {
61337       result = (Dali::Toolkit::Builder *)new Dali::Toolkit::Builder();
61338     } catch (std::out_of_range& e) {
61339       {
61340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61341       };
61342     } catch (std::exception& e) {
61343       {
61344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61345       };
61346     } catch (Dali::DaliException e) {
61347       {
61348         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61349       };
61350     } catch (...) {
61351       {
61352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61353       };
61354     }
61355   }
61356
61357   jresult = (void *)result;
61358   return jresult;
61359 }
61360
61361
61362 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_New() {
61363   void * jresult ;
61364   Dali::Toolkit::Builder result;
61365
61366   {
61367     try {
61368       result = Dali::Toolkit::Builder::New();
61369     } catch (std::out_of_range& e) {
61370       {
61371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61372       };
61373     } catch (std::exception& e) {
61374       {
61375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61376       };
61377     } catch (Dali::DaliException e) {
61378       {
61379         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61380       };
61381     } catch (...) {
61382       {
61383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61384       };
61385     }
61386   }
61387
61388   jresult = new Dali::Toolkit::Builder((const Dali::Toolkit::Builder &)result);
61389   return jresult;
61390 }
61391
61392
61393 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Builder(void * jarg1) {
61394   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61395
61396   arg1 = (Dali::Toolkit::Builder *)jarg1;
61397   {
61398     try {
61399       delete arg1;
61400     } catch (std::out_of_range& e) {
61401       {
61402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61403       };
61404     } catch (std::exception& e) {
61405       {
61406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61407       };
61408     } catch (Dali::DaliException e) {
61409       {
61410         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61411       };
61412     } catch (...) {
61413       {
61414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61415       };
61416     }
61417   }
61418
61419 }
61420
61421
61422 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_0(void * jarg1, char * jarg2, int jarg3) {
61423   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61424   std::string *arg2 = 0 ;
61425   Dali::Toolkit::Builder::UIFormat arg3 ;
61426
61427   arg1 = (Dali::Toolkit::Builder *)jarg1;
61428   if (!jarg2) {
61429     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61430     return ;
61431   }
61432   std::string arg2_str(jarg2);
61433   arg2 = &arg2_str;
61434   arg3 = (Dali::Toolkit::Builder::UIFormat)jarg3;
61435   {
61436     try {
61437       (arg1)->LoadFromString((std::string const &)*arg2,arg3);
61438     } catch (std::out_of_range& e) {
61439       {
61440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61441       };
61442     } catch (std::exception& e) {
61443       {
61444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61445       };
61446     } catch (Dali::DaliException e) {
61447       {
61448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61449       };
61450     } catch (...) {
61451       {
61452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61453       };
61454     }
61455   }
61456
61457
61458   //argout typemap for const std::string&
61459
61460 }
61461
61462
61463 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_1(void * jarg1, char * jarg2) {
61464   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61465   std::string *arg2 = 0 ;
61466
61467   arg1 = (Dali::Toolkit::Builder *)jarg1;
61468   if (!jarg2) {
61469     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61470     return ;
61471   }
61472   std::string arg2_str(jarg2);
61473   arg2 = &arg2_str;
61474   {
61475     try {
61476       (arg1)->LoadFromString((std::string const &)*arg2);
61477     } catch (std::out_of_range& e) {
61478       {
61479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61480       };
61481     } catch (std::exception& e) {
61482       {
61483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61484       };
61485     } catch (Dali::DaliException e) {
61486       {
61487         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61488       };
61489     } catch (...) {
61490       {
61491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61492       };
61493     }
61494   }
61495
61496
61497   //argout typemap for const std::string&
61498
61499 }
61500
61501
61502 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstants(void * jarg1, void * jarg2) {
61503   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61504   Dali::Property::Map *arg2 = 0 ;
61505
61506   arg1 = (Dali::Toolkit::Builder *)jarg1;
61507   arg2 = (Dali::Property::Map *)jarg2;
61508   if (!arg2) {
61509     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
61510     return ;
61511   }
61512   {
61513     try {
61514       (arg1)->AddConstants((Dali::Property::Map const &)*arg2);
61515     } catch (std::out_of_range& e) {
61516       {
61517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61518       };
61519     } catch (std::exception& e) {
61520       {
61521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61522       };
61523     } catch (Dali::DaliException e) {
61524       {
61525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61526       };
61527     } catch (...) {
61528       {
61529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61530       };
61531     }
61532   }
61533
61534 }
61535
61536
61537 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstant(void * jarg1, char * jarg2, void * jarg3) {
61538   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61539   std::string *arg2 = 0 ;
61540   Dali::Property::Value *arg3 = 0 ;
61541
61542   arg1 = (Dali::Toolkit::Builder *)jarg1;
61543   if (!jarg2) {
61544     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61545     return ;
61546   }
61547   std::string arg2_str(jarg2);
61548   arg2 = &arg2_str;
61549   arg3 = (Dali::Property::Value *)jarg3;
61550   if (!arg3) {
61551     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
61552     return ;
61553   }
61554   {
61555     try {
61556       (arg1)->AddConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
61557     } catch (std::out_of_range& e) {
61558       {
61559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61560       };
61561     } catch (std::exception& e) {
61562       {
61563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61564       };
61565     } catch (Dali::DaliException e) {
61566       {
61567         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61568       };
61569     } catch (...) {
61570       {
61571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61572       };
61573     }
61574   }
61575
61576
61577   //argout typemap for const std::string&
61578
61579 }
61580
61581
61582 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstants(void * jarg1) {
61583   void * jresult ;
61584   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61585   Dali::Property::Map *result = 0 ;
61586
61587   arg1 = (Dali::Toolkit::Builder *)jarg1;
61588   {
61589     try {
61590       result = (Dali::Property::Map *) &((Dali::Toolkit::Builder const *)arg1)->GetConstants();
61591     } catch (std::out_of_range& e) {
61592       {
61593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61594       };
61595     } catch (std::exception& e) {
61596       {
61597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61598       };
61599     } catch (Dali::DaliException e) {
61600       {
61601         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61602       };
61603     } catch (...) {
61604       {
61605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61606       };
61607     }
61608   }
61609
61610   jresult = (void *)result;
61611   return jresult;
61612 }
61613
61614
61615 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstant(void * jarg1, char * jarg2) {
61616   void * jresult ;
61617   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61618   std::string *arg2 = 0 ;
61619   Dali::Property::Value *result = 0 ;
61620
61621   arg1 = (Dali::Toolkit::Builder *)jarg1;
61622   if (!jarg2) {
61623     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61624     return 0;
61625   }
61626   std::string arg2_str(jarg2);
61627   arg2 = &arg2_str;
61628   {
61629     try {
61630       result = (Dali::Property::Value *) &((Dali::Toolkit::Builder const *)arg1)->GetConstant((std::string const &)*arg2);
61631     } catch (std::out_of_range& e) {
61632       {
61633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61634       };
61635     } catch (std::exception& e) {
61636       {
61637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61638       };
61639     } catch (Dali::DaliException e) {
61640       {
61641         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61642       };
61643     } catch (...) {
61644       {
61645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61646       };
61647     }
61648   }
61649
61650   jresult = (void *)result;
61651
61652   //argout typemap for const std::string&
61653
61654   return jresult;
61655 }
61656
61657
61658 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_0(void * jarg1, char * jarg2) {
61659   void * jresult ;
61660   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61661   std::string *arg2 = 0 ;
61662   Dali::Animation result;
61663
61664   arg1 = (Dali::Toolkit::Builder *)jarg1;
61665   if (!jarg2) {
61666     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61667     return 0;
61668   }
61669   std::string arg2_str(jarg2);
61670   arg2 = &arg2_str;
61671   {
61672     try {
61673       result = (arg1)->CreateAnimation((std::string const &)*arg2);
61674     } catch (std::out_of_range& e) {
61675       {
61676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61677       };
61678     } catch (std::exception& e) {
61679       {
61680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61681       };
61682     } catch (Dali::DaliException e) {
61683       {
61684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61685       };
61686     } catch (...) {
61687       {
61688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61689       };
61690     }
61691   }
61692
61693   jresult = new Dali::Animation((const Dali::Animation &)result);
61694
61695   //argout typemap for const std::string&
61696
61697   return jresult;
61698 }
61699
61700
61701 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
61702   void * jresult ;
61703   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61704   std::string *arg2 = 0 ;
61705   Dali::Property::Map *arg3 = 0 ;
61706   Dali::Animation result;
61707
61708   arg1 = (Dali::Toolkit::Builder *)jarg1;
61709   if (!jarg2) {
61710     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61711     return 0;
61712   }
61713   std::string arg2_str(jarg2);
61714   arg2 = &arg2_str;
61715   arg3 = (Dali::Property::Map *)jarg3;
61716   if (!arg3) {
61717     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
61718     return 0;
61719   }
61720   {
61721     try {
61722       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
61723     } catch (std::out_of_range& e) {
61724       {
61725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61726       };
61727     } catch (std::exception& e) {
61728       {
61729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61730       };
61731     } catch (Dali::DaliException e) {
61732       {
61733         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61734       };
61735     } catch (...) {
61736       {
61737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61738       };
61739     }
61740   }
61741
61742   jresult = new Dali::Animation((const Dali::Animation &)result);
61743
61744   //argout typemap for const std::string&
61745
61746   return jresult;
61747 }
61748
61749
61750 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
61751   void * jresult ;
61752   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61753   std::string *arg2 = 0 ;
61754   Dali::Actor arg3 ;
61755   Dali::Actor *argp3 ;
61756   Dali::Animation result;
61757
61758   arg1 = (Dali::Toolkit::Builder *)jarg1;
61759   if (!jarg2) {
61760     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61761     return 0;
61762   }
61763   std::string arg2_str(jarg2);
61764   arg2 = &arg2_str;
61765   argp3 = (Dali::Actor *)jarg3;
61766   if (!argp3) {
61767     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61768     return 0;
61769   }
61770   arg3 = *argp3;
61771   {
61772     try {
61773       result = (arg1)->CreateAnimation((std::string const &)*arg2,arg3);
61774     } catch (std::out_of_range& e) {
61775       {
61776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61777       };
61778     } catch (std::exception& e) {
61779       {
61780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61781       };
61782     } catch (Dali::DaliException e) {
61783       {
61784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61785       };
61786     } catch (...) {
61787       {
61788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61789       };
61790     }
61791   }
61792
61793   jresult = new Dali::Animation((const Dali::Animation &)result);
61794
61795   //argout typemap for const std::string&
61796
61797   return jresult;
61798 }
61799
61800
61801 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_3(void * jarg1, char * jarg2, void * jarg3, void * jarg4) {
61802   void * jresult ;
61803   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61804   std::string *arg2 = 0 ;
61805   Dali::Property::Map *arg3 = 0 ;
61806   Dali::Actor arg4 ;
61807   Dali::Actor *argp4 ;
61808   Dali::Animation result;
61809
61810   arg1 = (Dali::Toolkit::Builder *)jarg1;
61811   if (!jarg2) {
61812     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61813     return 0;
61814   }
61815   std::string arg2_str(jarg2);
61816   arg2 = &arg2_str;
61817   arg3 = (Dali::Property::Map *)jarg3;
61818   if (!arg3) {
61819     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
61820     return 0;
61821   }
61822   argp4 = (Dali::Actor *)jarg4;
61823   if (!argp4) {
61824     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61825     return 0;
61826   }
61827   arg4 = *argp4;
61828   {
61829     try {
61830       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3,arg4);
61831     } catch (std::out_of_range& e) {
61832       {
61833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61834       };
61835     } catch (std::exception& e) {
61836       {
61837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61838       };
61839     } catch (Dali::DaliException e) {
61840       {
61841         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61842       };
61843     } catch (...) {
61844       {
61845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61846       };
61847     }
61848   }
61849
61850   jresult = new Dali::Animation((const Dali::Animation &)result);
61851
61852   //argout typemap for const std::string&
61853
61854   return jresult;
61855 }
61856
61857
61858 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_0(void * jarg1, char * jarg2) {
61859   void * jresult ;
61860   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61861   std::string *arg2 = 0 ;
61862   Dali::BaseHandle result;
61863
61864   arg1 = (Dali::Toolkit::Builder *)jarg1;
61865   if (!jarg2) {
61866     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61867     return 0;
61868   }
61869   std::string arg2_str(jarg2);
61870   arg2 = &arg2_str;
61871   {
61872     try {
61873       result = (arg1)->Create((std::string const &)*arg2);
61874     } catch (std::out_of_range& e) {
61875       {
61876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61877       };
61878     } catch (std::exception& e) {
61879       {
61880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61881       };
61882     } catch (Dali::DaliException e) {
61883       {
61884         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61885       };
61886     } catch (...) {
61887       {
61888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61889       };
61890     }
61891   }
61892
61893   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
61894
61895   //argout typemap for const std::string&
61896
61897   return jresult;
61898 }
61899
61900
61901 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
61902   void * jresult ;
61903   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61904   std::string *arg2 = 0 ;
61905   Dali::Property::Map *arg3 = 0 ;
61906   Dali::BaseHandle result;
61907
61908   arg1 = (Dali::Toolkit::Builder *)jarg1;
61909   if (!jarg2) {
61910     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61911     return 0;
61912   }
61913   std::string arg2_str(jarg2);
61914   arg2 = &arg2_str;
61915   arg3 = (Dali::Property::Map *)jarg3;
61916   if (!arg3) {
61917     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
61918     return 0;
61919   }
61920   {
61921     try {
61922       result = (arg1)->Create((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
61923     } catch (std::out_of_range& e) {
61924       {
61925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61926       };
61927     } catch (std::exception& e) {
61928       {
61929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61930       };
61931     } catch (Dali::DaliException e) {
61932       {
61933         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61934       };
61935     } catch (...) {
61936       {
61937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61938       };
61939     }
61940   }
61941
61942   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
61943
61944   //argout typemap for const std::string&
61945
61946   return jresult;
61947 }
61948
61949
61950 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateFromJson(void * jarg1, char * jarg2) {
61951   void * jresult ;
61952   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61953   std::string *arg2 = 0 ;
61954   Dali::BaseHandle result;
61955
61956   arg1 = (Dali::Toolkit::Builder *)jarg1;
61957   if (!jarg2) {
61958     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61959     return 0;
61960   }
61961   std::string arg2_str(jarg2);
61962   arg2 = &arg2_str;
61963   {
61964     try {
61965       result = (arg1)->CreateFromJson((std::string const &)*arg2);
61966     } catch (std::out_of_range& e) {
61967       {
61968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61969       };
61970     } catch (std::exception& e) {
61971       {
61972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61973       };
61974     } catch (Dali::DaliException e) {
61975       {
61976         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61977       };
61978     } catch (...) {
61979       {
61980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61981       };
61982     }
61983   }
61984
61985   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
61986
61987   //argout typemap for const std::string&
61988
61989   return jresult;
61990 }
61991
61992
61993 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyStyle(void * jarg1, char * jarg2, void * jarg3) {
61994   unsigned int jresult ;
61995   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61996   std::string *arg2 = 0 ;
61997   Dali::Handle *arg3 = 0 ;
61998   bool result;
61999
62000   arg1 = (Dali::Toolkit::Builder *)jarg1;
62001   if (!jarg2) {
62002     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62003     return 0;
62004   }
62005   std::string arg2_str(jarg2);
62006   arg2 = &arg2_str;
62007   arg3 = (Dali::Handle *)jarg3;
62008   if (!arg3) {
62009     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
62010     return 0;
62011   }
62012   {
62013     try {
62014       result = (bool)(arg1)->ApplyStyle((std::string const &)*arg2,*arg3);
62015     } catch (std::out_of_range& e) {
62016       {
62017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62018       };
62019     } catch (std::exception& e) {
62020       {
62021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62022       };
62023     } catch (Dali::DaliException e) {
62024       {
62025         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62026       };
62027     } catch (...) {
62028       {
62029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62030       };
62031     }
62032   }
62033
62034   jresult = result;
62035
62036   //argout typemap for const std::string&
62037
62038   return jresult;
62039 }
62040
62041
62042 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyFromJson(void * jarg1, void * jarg2, char * jarg3) {
62043   unsigned int jresult ;
62044   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62045   Dali::Handle *arg2 = 0 ;
62046   std::string *arg3 = 0 ;
62047   bool result;
62048
62049   arg1 = (Dali::Toolkit::Builder *)jarg1;
62050   arg2 = (Dali::Handle *)jarg2;
62051   if (!arg2) {
62052     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
62053     return 0;
62054   }
62055   if (!jarg3) {
62056     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62057     return 0;
62058   }
62059   std::string arg3_str(jarg3);
62060   arg3 = &arg3_str;
62061   {
62062     try {
62063       result = (bool)(arg1)->ApplyFromJson(*arg2,(std::string const &)*arg3);
62064     } catch (std::out_of_range& e) {
62065       {
62066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62067       };
62068     } catch (std::exception& e) {
62069       {
62070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62071       };
62072     } catch (Dali::DaliException e) {
62073       {
62074         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62075       };
62076     } catch (...) {
62077       {
62078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62079       };
62080     }
62081   }
62082
62083   jresult = result;
62084
62085   //argout typemap for const std::string&
62086
62087   return jresult;
62088 }
62089
62090
62091 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_0(void * jarg1, void * jarg2) {
62092   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62093   Dali::Actor arg2 ;
62094   Dali::Actor *argp2 ;
62095
62096   arg1 = (Dali::Toolkit::Builder *)jarg1;
62097   argp2 = (Dali::Actor *)jarg2;
62098   if (!argp2) {
62099     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62100     return ;
62101   }
62102   arg2 = *argp2;
62103   {
62104     try {
62105       (arg1)->AddActors(arg2);
62106     } catch (std::out_of_range& e) {
62107       {
62108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62109       };
62110     } catch (std::exception& e) {
62111       {
62112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62113       };
62114     } catch (Dali::DaliException e) {
62115       {
62116         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62117       };
62118     } catch (...) {
62119       {
62120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62121       };
62122     }
62123   }
62124
62125 }
62126
62127
62128 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
62129   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62130   std::string *arg2 = 0 ;
62131   Dali::Actor arg3 ;
62132   Dali::Actor *argp3 ;
62133
62134   arg1 = (Dali::Toolkit::Builder *)jarg1;
62135   if (!jarg2) {
62136     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62137     return ;
62138   }
62139   std::string arg2_str(jarg2);
62140   arg2 = &arg2_str;
62141   argp3 = (Dali::Actor *)jarg3;
62142   if (!argp3) {
62143     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62144     return ;
62145   }
62146   arg3 = *argp3;
62147   {
62148     try {
62149       (arg1)->AddActors((std::string const &)*arg2,arg3);
62150     } catch (std::out_of_range& e) {
62151       {
62152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62153       };
62154     } catch (std::exception& e) {
62155       {
62156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62157       };
62158     } catch (Dali::DaliException e) {
62159       {
62160         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62161       };
62162     } catch (...) {
62163       {
62164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62165       };
62166     }
62167   }
62168
62169
62170   //argout typemap for const std::string&
62171
62172 }
62173
62174
62175 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_CreateRenderTask(void * jarg1, char * jarg2) {
62176   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62177   std::string *arg2 = 0 ;
62178
62179   arg1 = (Dali::Toolkit::Builder *)jarg1;
62180   if (!jarg2) {
62181     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62182     return ;
62183   }
62184   std::string arg2_str(jarg2);
62185   arg2 = &arg2_str;
62186   {
62187     try {
62188       (arg1)->CreateRenderTask((std::string const &)*arg2);
62189     } catch (std::out_of_range& e) {
62190       {
62191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62192       };
62193     } catch (std::exception& e) {
62194       {
62195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62196       };
62197     } catch (Dali::DaliException e) {
62198       {
62199         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62200       };
62201     } catch (...) {
62202       {
62203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62204       };
62205     }
62206   }
62207
62208
62209   //argout typemap for const std::string&
62210
62211 }
62212
62213
62214 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetFrameBufferImage(void * jarg1, char * jarg2) {
62215   void * jresult ;
62216   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62217   std::string *arg2 = 0 ;
62218   Dali::FrameBufferImage result;
62219
62220   arg1 = (Dali::Toolkit::Builder *)jarg1;
62221   if (!jarg2) {
62222     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62223     return 0;
62224   }
62225   std::string arg2_str(jarg2);
62226   arg2 = &arg2_str;
62227   {
62228     try {
62229       result = (arg1)->GetFrameBufferImage((std::string const &)*arg2);
62230     } catch (std::out_of_range& e) {
62231       {
62232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62233       };
62234     } catch (std::exception& e) {
62235       {
62236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62237       };
62238     } catch (Dali::DaliException e) {
62239       {
62240         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62241       };
62242     } catch (...) {
62243       {
62244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62245       };
62246     }
62247   }
62248
62249   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
62250
62251   //argout typemap for const std::string&
62252
62253   return jresult;
62254 }
62255
62256
62257 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPath(void * jarg1, char * jarg2) {
62258   void * jresult ;
62259   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62260   std::string *arg2 = 0 ;
62261   Dali::Path result;
62262
62263   arg1 = (Dali::Toolkit::Builder *)jarg1;
62264   if (!jarg2) {
62265     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62266     return 0;
62267   }
62268   std::string arg2_str(jarg2);
62269   arg2 = &arg2_str;
62270   {
62271     try {
62272       result = (arg1)->GetPath((std::string const &)*arg2);
62273     } catch (std::out_of_range& e) {
62274       {
62275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62276       };
62277     } catch (std::exception& e) {
62278       {
62279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62280       };
62281     } catch (Dali::DaliException e) {
62282       {
62283         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62284       };
62285     } catch (...) {
62286       {
62287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62288       };
62289     }
62290   }
62291
62292   jresult = new Dali::Path((const Dali::Path &)result);
62293
62294   //argout typemap for const std::string&
62295
62296   return jresult;
62297 }
62298
62299
62300 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPathConstrainer(void * jarg1, char * jarg2) {
62301   void * jresult ;
62302   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62303   std::string *arg2 = 0 ;
62304   Dali::PathConstrainer result;
62305
62306   arg1 = (Dali::Toolkit::Builder *)jarg1;
62307   if (!jarg2) {
62308     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62309     return 0;
62310   }
62311   std::string arg2_str(jarg2);
62312   arg2 = &arg2_str;
62313   {
62314     try {
62315       result = (arg1)->GetPathConstrainer((std::string const &)*arg2);
62316     } catch (std::out_of_range& e) {
62317       {
62318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62319       };
62320     } catch (std::exception& e) {
62321       {
62322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62323       };
62324     } catch (Dali::DaliException e) {
62325       {
62326         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62327       };
62328     } catch (...) {
62329       {
62330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62331       };
62332     }
62333   }
62334
62335   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
62336
62337   //argout typemap for const std::string&
62338
62339   return jresult;
62340 }
62341
62342
62343 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetLinearConstrainer(void * jarg1, char * jarg2) {
62344   void * jresult ;
62345   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62346   std::string *arg2 = 0 ;
62347   Dali::LinearConstrainer result;
62348
62349   arg1 = (Dali::Toolkit::Builder *)jarg1;
62350   if (!jarg2) {
62351     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62352     return 0;
62353   }
62354   std::string arg2_str(jarg2);
62355   arg2 = &arg2_str;
62356   {
62357     try {
62358       result = (arg1)->GetLinearConstrainer((std::string const &)*arg2);
62359     } catch (std::out_of_range& e) {
62360       {
62361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62362       };
62363     } catch (std::exception& e) {
62364       {
62365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62366       };
62367     } catch (Dali::DaliException e) {
62368       {
62369         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62370       };
62371     } catch (...) {
62372       {
62373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62374       };
62375     }
62376   }
62377
62378   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
62379
62380   //argout typemap for const std::string&
62381
62382   return jresult;
62383 }
62384
62385
62386 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_QuitSignal(void * jarg1) {
62387   void * jresult ;
62388   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62389   Dali::Toolkit::Builder::BuilderSignalType *result = 0 ;
62390
62391   arg1 = (Dali::Toolkit::Builder *)jarg1;
62392   {
62393     try {
62394       result = (Dali::Toolkit::Builder::BuilderSignalType *) &(arg1)->QuitSignal();
62395     } catch (std::out_of_range& e) {
62396       {
62397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62398       };
62399     } catch (std::exception& e) {
62400       {
62401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62402       };
62403     } catch (Dali::DaliException e) {
62404       {
62405         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62406       };
62407     } catch (...) {
62408       {
62409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62410       };
62411     }
62412   }
62413
62414   jresult = (void *)result;
62415   return jresult;
62416 }
62417
62418
62419 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_0() {
62420   void * jresult ;
62421   Dali::Toolkit::TransitionData *result = 0 ;
62422
62423   {
62424     try {
62425       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData();
62426     } catch (std::out_of_range& e) {
62427       {
62428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62429       };
62430     } catch (std::exception& e) {
62431       {
62432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62433       };
62434     } catch (Dali::DaliException e) {
62435       {
62436         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62437       };
62438     } catch (...) {
62439       {
62440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62441       };
62442     }
62443   }
62444
62445   jresult = (void *)result;
62446   return jresult;
62447 }
62448
62449 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TransitionData(void * jarg1) {
62450   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
62451
62452   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62453   {
62454     try {
62455       delete arg1;
62456     } catch (std::out_of_range& e) {
62457       {
62458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62459       };
62460     } catch (std::exception& e) {
62461       {
62462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62463       };
62464     } catch (Dali::DaliException e) {
62465       {
62466         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62467       };
62468     } catch (...) {
62469       {
62470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62471       };
62472     }
62473   }
62474
62475 }
62476
62477
62478 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_0(void * jarg1) {
62479   void * jresult ;
62480   Dali::Property::Map *arg1 = 0 ;
62481   Dali::Toolkit::TransitionData result;
62482
62483   arg1 = (Dali::Property::Map *)jarg1;
62484   if (!arg1) {
62485     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
62486     return 0;
62487   }
62488   {
62489     try {
62490       result = Dali::Toolkit::TransitionData::New((Dali::Property::Map const &)*arg1);
62491     } catch (std::out_of_range& e) {
62492       {
62493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62494       };
62495     } catch (std::exception& e) {
62496       {
62497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62498       };
62499     } catch (Dali::DaliException e) {
62500       {
62501         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62502       };
62503     } catch (...) {
62504       {
62505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62506       };
62507     }
62508   }
62509
62510   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
62511   return jresult;
62512 }
62513
62514
62515 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_1(void * jarg1) {
62516   void * jresult ;
62517   Dali::Property::Array *arg1 = 0 ;
62518   Dali::Toolkit::TransitionData result;
62519
62520   arg1 = (Dali::Property::Array *)jarg1;
62521   if (!arg1) {
62522     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
62523     return 0;
62524   }
62525   {
62526     try {
62527       result = Dali::Toolkit::TransitionData::New((Dali::Property::Array const &)*arg1);
62528     } catch (std::out_of_range& e) {
62529       {
62530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62531       };
62532     } catch (std::exception& e) {
62533       {
62534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62535       };
62536     } catch (Dali::DaliException e) {
62537       {
62538         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62539       };
62540     } catch (...) {
62541       {
62542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62543       };
62544     }
62545   }
62546
62547   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
62548   return jresult;
62549 }
62550
62551
62552 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_DownCast(void * jarg1) {
62553   void * jresult ;
62554   Dali::BaseHandle arg1 ;
62555   Dali::BaseHandle *argp1 ;
62556   Dali::Toolkit::TransitionData result;
62557
62558   argp1 = (Dali::BaseHandle *)jarg1;
62559   if (!argp1) {
62560     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
62561     return 0;
62562   }
62563   arg1 = *argp1;
62564   {
62565     try {
62566       result = Dali::Toolkit::TransitionData::DownCast(arg1);
62567     } catch (std::out_of_range& e) {
62568       {
62569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62570       };
62571     } catch (std::exception& e) {
62572       {
62573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62574       };
62575     } catch (Dali::DaliException e) {
62576       {
62577         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62578       };
62579     } catch (...) {
62580       {
62581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62582       };
62583     }
62584   }
62585
62586   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
62587   return jresult;
62588 }
62589
62590
62591 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_1(void * jarg1) {
62592   void * jresult ;
62593   Dali::Toolkit::TransitionData *arg1 = 0 ;
62594   Dali::Toolkit::TransitionData *result = 0 ;
62595
62596   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62597   if (!arg1) {
62598     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
62599     return 0;
62600   }
62601   {
62602     try {
62603       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData((Dali::Toolkit::TransitionData const &)*arg1);
62604     } catch (std::out_of_range& e) {
62605       {
62606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62607       };
62608     } catch (std::exception& e) {
62609       {
62610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62611       };
62612     } catch (Dali::DaliException e) {
62613       {
62614         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62615       };
62616     } catch (...) {
62617       {
62618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62619       };
62620     }
62621   }
62622
62623   jresult = (void *)result;
62624   return jresult;
62625 }
62626
62627
62628 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_Assign(void * jarg1, void * jarg2) {
62629   void * jresult ;
62630   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
62631   Dali::Toolkit::TransitionData *arg2 = 0 ;
62632   Dali::Toolkit::TransitionData *result = 0 ;
62633
62634   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62635   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
62636   if (!arg2) {
62637     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
62638     return 0;
62639   }
62640   {
62641     try {
62642       result = (Dali::Toolkit::TransitionData *) &(arg1)->operator =((Dali::Toolkit::TransitionData const &)*arg2);
62643     } catch (std::out_of_range& e) {
62644       {
62645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62646       };
62647     } catch (std::exception& e) {
62648       {
62649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62650       };
62651     } catch (Dali::DaliException e) {
62652       {
62653         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62654       };
62655     } catch (...) {
62656       {
62657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62658       };
62659     }
62660   }
62661
62662   jresult = (void *)result;
62663   return jresult;
62664 }
62665
62666
62667 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TransitionData_Count(void * jarg1) {
62668   unsigned long jresult ;
62669   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
62670   size_t result;
62671
62672   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62673   {
62674     try {
62675       result = ((Dali::Toolkit::TransitionData const *)arg1)->Count();
62676     } catch (std::out_of_range& e) {
62677       {
62678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62679       };
62680     } catch (std::exception& e) {
62681       {
62682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62683       };
62684     } catch (Dali::DaliException e) {
62685       {
62686         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62687       };
62688     } catch (...) {
62689       {
62690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62691       };
62692     }
62693   }
62694
62695   jresult = (unsigned long)result;
62696   return jresult;
62697 }
62698
62699
62700 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_GetAnimatorAt(void * jarg1, unsigned long jarg2) {
62701   void * jresult ;
62702   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
62703   size_t arg2 ;
62704   Dali::Property::Map result;
62705
62706   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62707   arg2 = (size_t)jarg2;
62708   {
62709     try {
62710       result = (arg1)->GetAnimatorAt(arg2);
62711     } catch (std::out_of_range& e) {
62712       {
62713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62714       };
62715     } catch (std::exception& e) {
62716       {
62717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62718       };
62719     } catch (Dali::DaliException e) {
62720       {
62721         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62722       };
62723     } catch (...) {
62724       {
62725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62726       };
62727     }
62728   }
62729
62730   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
62731   return jresult;
62732 }
62733
62734
62735 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_CONTENT_get() {
62736   int jresult ;
62737   int result;
62738
62739   {
62740     try {
62741       result = (int)Dali::Toolkit::Tooltip::Property::CONTENT;
62742     } catch (std::out_of_range& e) {
62743       {
62744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62745       };
62746     } catch (std::exception& e) {
62747       {
62748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62749       };
62750     } catch (Dali::DaliException e) {
62751       {
62752         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62753       };
62754     } catch (...) {
62755       {
62756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62757       };
62758     }
62759   }
62760
62761   jresult = (int)result;
62762   return jresult;
62763 }
62764
62765
62766 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_LAYOUT_get() {
62767   int jresult ;
62768   int result;
62769
62770   {
62771     try {
62772       result = (int)Dali::Toolkit::Tooltip::Property::LAYOUT;
62773     } catch (std::out_of_range& e) {
62774       {
62775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62776       };
62777     } catch (std::exception& e) {
62778       {
62779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62780       };
62781     } catch (Dali::DaliException e) {
62782       {
62783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62784       };
62785     } catch (...) {
62786       {
62787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62788       };
62789     }
62790   }
62791
62792   jresult = (int)result;
62793   return jresult;
62794 }
62795
62796
62797 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_WAIT_TIME_get() {
62798   int jresult ;
62799   int result;
62800
62801   {
62802     try {
62803       result = (int)Dali::Toolkit::Tooltip::Property::WAIT_TIME;
62804     } catch (std::out_of_range& e) {
62805       {
62806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62807       };
62808     } catch (std::exception& e) {
62809       {
62810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62811       };
62812     } catch (Dali::DaliException e) {
62813       {
62814         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62815       };
62816     } catch (...) {
62817       {
62818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62819       };
62820     }
62821   }
62822
62823   jresult = (int)result;
62824   return jresult;
62825 }
62826
62827
62828 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_get() {
62829   int jresult ;
62830   int result;
62831
62832   {
62833     try {
62834       result = (int)Dali::Toolkit::Tooltip::Property::BACKGROUND;
62835     } catch (std::out_of_range& e) {
62836       {
62837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62838       };
62839     } catch (std::exception& e) {
62840       {
62841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62842       };
62843     } catch (Dali::DaliException e) {
62844       {
62845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62846       };
62847     } catch (...) {
62848       {
62849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62850       };
62851     }
62852   }
62853
62854   jresult = (int)result;
62855   return jresult;
62856 }
62857
62858
62859 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_get() {
62860   int jresult ;
62861   int result;
62862
62863   {
62864     try {
62865       result = (int)Dali::Toolkit::Tooltip::Property::TAIL;
62866     } catch (std::out_of_range& e) {
62867       {
62868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62869       };
62870     } catch (std::exception& e) {
62871       {
62872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62873       };
62874     } catch (Dali::DaliException e) {
62875       {
62876         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62877       };
62878     } catch (...) {
62879       {
62880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62881       };
62882     }
62883   }
62884
62885   jresult = (int)result;
62886   return jresult;
62887 }
62888
62889
62890 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_POSITION_get() {
62891   int jresult ;
62892   int result;
62893
62894   {
62895     try {
62896       result = (int)Dali::Toolkit::Tooltip::Property::POSITION;
62897     } catch (std::out_of_range& e) {
62898       {
62899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62900       };
62901     } catch (std::exception& e) {
62902       {
62903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62904       };
62905     } catch (Dali::DaliException e) {
62906       {
62907         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62908       };
62909     } catch (...) {
62910       {
62911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62912       };
62913     }
62914   }
62915
62916   jresult = (int)result;
62917   return jresult;
62918 }
62919
62920
62921 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_HOVER_POINT_OFFSET_get() {
62922   int jresult ;
62923   int result;
62924
62925   {
62926     try {
62927       result = (int)Dali::Toolkit::Tooltip::Property::HOVER_POINT_OFFSET;
62928     } catch (std::out_of_range& e) {
62929       {
62930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62931       };
62932     } catch (std::exception& e) {
62933       {
62934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62935       };
62936     } catch (Dali::DaliException e) {
62937       {
62938         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62939       };
62940     } catch (...) {
62941       {
62942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62943       };
62944     }
62945   }
62946
62947   jresult = (int)result;
62948   return jresult;
62949 }
62950
62951
62952 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_MOVEMENT_THRESHOLD_get() {
62953   int jresult ;
62954   int result;
62955
62956   {
62957     try {
62958       result = (int)Dali::Toolkit::Tooltip::Property::MOVEMENT_THRESHOLD;
62959     } catch (std::out_of_range& e) {
62960       {
62961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62962       };
62963     } catch (std::exception& e) {
62964       {
62965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62966       };
62967     } catch (Dali::DaliException e) {
62968       {
62969         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62970       };
62971     } catch (...) {
62972       {
62973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62974       };
62975     }
62976   }
62977
62978   jresult = (int)result;
62979   return jresult;
62980 }
62981
62982
62983 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_DISAPPEAR_ON_MOVEMENT_get() {
62984   int jresult ;
62985   int result;
62986
62987   {
62988     try {
62989       result = (int)Dali::Toolkit::Tooltip::Property::DISAPPEAR_ON_MOVEMENT;
62990     } catch (std::out_of_range& e) {
62991       {
62992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62993       };
62994     } catch (std::exception& e) {
62995       {
62996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62997       };
62998     } catch (Dali::DaliException e) {
62999       {
63000         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63001       };
63002     } catch (...) {
63003       {
63004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63005       };
63006     }
63007   }
63008
63009   jresult = (int)result;
63010   return jresult;
63011 }
63012
63013
63014 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_VISUAL_get() {
63015   int jresult ;
63016   int result;
63017
63018   {
63019     try {
63020       result = (int)Dali::Toolkit::Tooltip::Background::Property::VISUAL;
63021     } catch (std::out_of_range& e) {
63022       {
63023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63024       };
63025     } catch (std::exception& e) {
63026       {
63027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63028       };
63029     } catch (Dali::DaliException e) {
63030       {
63031         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63032       };
63033     } catch (...) {
63034       {
63035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63036       };
63037     }
63038   }
63039
63040   jresult = (int)result;
63041   return jresult;
63042 }
63043
63044
63045 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_BORDER_get() {
63046   int jresult ;
63047   int result;
63048
63049   {
63050     try {
63051       result = (int)Dali::Toolkit::Tooltip::Background::Property::BORDER;
63052     } catch (std::out_of_range& e) {
63053       {
63054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63055       };
63056     } catch (std::exception& e) {
63057       {
63058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63059       };
63060     } catch (Dali::DaliException e) {
63061       {
63062         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63063       };
63064     } catch (...) {
63065       {
63066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63067       };
63068     }
63069   }
63070
63071   jresult = (int)result;
63072   return jresult;
63073 }
63074
63075
63076 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_VISIBILITY_get() {
63077   int jresult ;
63078   int result;
63079
63080   {
63081     try {
63082       result = (int)Dali::Toolkit::Tooltip::Tail::Property::VISIBILITY;
63083     } catch (std::out_of_range& e) {
63084       {
63085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63086       };
63087     } catch (std::exception& e) {
63088       {
63089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63090       };
63091     } catch (Dali::DaliException e) {
63092       {
63093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63094       };
63095     } catch (...) {
63096       {
63097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63098       };
63099     }
63100   }
63101
63102   jresult = (int)result;
63103   return jresult;
63104 }
63105
63106
63107 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_ABOVE_VISUAL_get() {
63108   int jresult ;
63109   int result;
63110
63111   {
63112     try {
63113       result = (int)Dali::Toolkit::Tooltip::Tail::Property::ABOVE_VISUAL;
63114     } catch (std::out_of_range& e) {
63115       {
63116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63117       };
63118     } catch (std::exception& e) {
63119       {
63120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63121       };
63122     } catch (Dali::DaliException e) {
63123       {
63124         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63125       };
63126     } catch (...) {
63127       {
63128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63129       };
63130     }
63131   }
63132
63133   jresult = (int)result;
63134   return jresult;
63135 }
63136
63137
63138 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_BELOW_VISUAL_get() {
63139   int jresult ;
63140   int result;
63141
63142   {
63143     try {
63144       result = (int)Dali::Toolkit::Tooltip::Tail::Property::BELOW_VISUAL;
63145     } catch (std::out_of_range& e) {
63146       {
63147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63148       };
63149     } catch (std::exception& e) {
63150       {
63151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63152       };
63153     } catch (Dali::DaliException e) {
63154       {
63155         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63156       };
63157     } catch (...) {
63158       {
63159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63160       };
63161     }
63162   }
63163
63164   jresult = (int)result;
63165   return jresult;
63166 }
63167
63168
63169 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_New() {
63170   void * jresult ;
63171   Dali::Toolkit::Control result;
63172
63173   {
63174     try {
63175       result = Dali::Toolkit::Internal::Control::New();
63176     } catch (std::out_of_range& e) {
63177       {
63178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63179       };
63180     } catch (std::exception& e) {
63181       {
63182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63183       };
63184     } catch (Dali::DaliException e) {
63185       {
63186         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63187       };
63188     } catch (...) {
63189       {
63190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63191       };
63192     }
63193   }
63194
63195   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
63196   return jresult;
63197 }
63198
63199
63200 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetStyleName(void * jarg1, char * jarg2) {
63201   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63202   std::string *arg2 = 0 ;
63203
63204   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63205   if (!jarg2) {
63206     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
63207     return ;
63208   }
63209   std::string arg2_str(jarg2);
63210   arg2 = &arg2_str;
63211   {
63212     try {
63213       (arg1)->SetStyleName((std::string const &)*arg2);
63214     } catch (std::out_of_range& e) {
63215       {
63216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63217       };
63218     } catch (std::exception& e) {
63219       {
63220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63221       };
63222     } catch (Dali::DaliException e) {
63223       {
63224         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63225       };
63226     } catch (...) {
63227       {
63228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63229       };
63230     }
63231   }
63232
63233
63234   //argout typemap for const std::string&
63235
63236 }
63237
63238
63239 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ViewImpl_GetStyleName(void * jarg1) {
63240   char * jresult ;
63241   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63242   std::string *result = 0 ;
63243
63244   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63245   {
63246     try {
63247       result = (std::string *) &((Dali::Toolkit::Internal::Control const *)arg1)->GetStyleName();
63248     } catch (std::out_of_range& e) {
63249       {
63250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63251       };
63252     } catch (std::exception& e) {
63253       {
63254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63255       };
63256     } catch (Dali::DaliException e) {
63257       {
63258         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63259       };
63260     } catch (...) {
63261       {
63262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63263       };
63264     }
63265   }
63266
63267   jresult = SWIG_csharp_string_callback(result->c_str());
63268   return jresult;
63269 }
63270
63271
63272 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundColor(void * jarg1, void * jarg2) {
63273   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63274   Dali::Vector4 *arg2 = 0 ;
63275
63276   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63277   arg2 = (Dali::Vector4 *)jarg2;
63278   if (!arg2) {
63279     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
63280     return ;
63281   }
63282   {
63283     try {
63284       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
63285     } catch (std::out_of_range& e) {
63286       {
63287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63288       };
63289     } catch (std::exception& e) {
63290       {
63291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63292       };
63293     } catch (Dali::DaliException e) {
63294       {
63295         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63296       };
63297     } catch (...) {
63298       {
63299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63300       };
63301     }
63302   }
63303
63304 }
63305
63306
63307 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetBackgroundColor(void * jarg1) {
63308   void * jresult ;
63309   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63310   Dali::Vector4 result;
63311
63312   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63313   {
63314     try {
63315       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetBackgroundColor();
63316     } catch (std::out_of_range& e) {
63317       {
63318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63319       };
63320     } catch (std::exception& e) {
63321       {
63322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63323       };
63324     } catch (Dali::DaliException e) {
63325       {
63326         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63327       };
63328     } catch (...) {
63329       {
63330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63331       };
63332     }
63333   }
63334
63335   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
63336   return jresult;
63337 }
63338
63339
63340 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundImage(void * jarg1, void * jarg2) {
63341   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63342   Dali::Image arg2 ;
63343   Dali::Image *argp2 ;
63344
63345   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63346   argp2 = (Dali::Image *)jarg2;
63347   if (!argp2) {
63348     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
63349     return ;
63350   }
63351   arg2 = *argp2;
63352   {
63353     try {
63354       (arg1)->SetBackgroundImage(arg2);
63355     } catch (std::out_of_range& e) {
63356       {
63357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63358       };
63359     } catch (std::exception& e) {
63360       {
63361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63362       };
63363     } catch (Dali::DaliException e) {
63364       {
63365         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63366       };
63367     } catch (...) {
63368       {
63369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63370       };
63371     }
63372   }
63373
63374 }
63375
63376
63377 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackground(void * jarg1, void * jarg2) {
63378   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63379   Dali::Property::Map *arg2 = 0 ;
63380
63381   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63382   arg2 = (Dali::Property::Map *)jarg2;
63383   if (!arg2) {
63384     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
63385     return ;
63386   }
63387   {
63388     try {
63389       (arg1)->SetBackground((Dali::Property::Map const &)*arg2);
63390     } catch (std::out_of_range& e) {
63391       {
63392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63393       };
63394     } catch (std::exception& e) {
63395       {
63396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63397       };
63398     } catch (Dali::DaliException e) {
63399       {
63400         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63401       };
63402     } catch (...) {
63403       {
63404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63405       };
63406     }
63407   }
63408
63409 }
63410
63411
63412 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearBackground(void * jarg1) {
63413   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63414
63415   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63416   {
63417     try {
63418       (arg1)->ClearBackground();
63419     } catch (std::out_of_range& e) {
63420       {
63421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63422       };
63423     } catch (std::exception& e) {
63424       {
63425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63426       };
63427     } catch (Dali::DaliException e) {
63428       {
63429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63430       };
63431     } catch (...) {
63432       {
63433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63434       };
63435     }
63436   }
63437
63438 }
63439
63440
63441 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_EnableGestureDetection(void * jarg1, int jarg2) {
63442   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63443   Dali::Gesture::Type arg2 ;
63444
63445   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63446   arg2 = (Dali::Gesture::Type)jarg2;
63447   {
63448     try {
63449       (arg1)->EnableGestureDetection(arg2);
63450     } catch (std::out_of_range& e) {
63451       {
63452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63453       };
63454     } catch (std::exception& e) {
63455       {
63456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63457       };
63458     } catch (Dali::DaliException e) {
63459       {
63460         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63461       };
63462     } catch (...) {
63463       {
63464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63465       };
63466     }
63467   }
63468
63469 }
63470
63471
63472 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_DisableGestureDetection(void * jarg1, int jarg2) {
63473   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63474   Dali::Gesture::Type arg2 ;
63475
63476   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63477   arg2 = (Dali::Gesture::Type)jarg2;
63478   {
63479     try {
63480       (arg1)->DisableGestureDetection(arg2);
63481     } catch (std::out_of_range& e) {
63482       {
63483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63484       };
63485     } catch (std::exception& e) {
63486       {
63487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63488       };
63489     } catch (Dali::DaliException e) {
63490       {
63491         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63492       };
63493     } catch (...) {
63494       {
63495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63496       };
63497     }
63498   }
63499
63500 }
63501
63502
63503 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPinchGestureDetector(void * jarg1) {
63504   void * jresult ;
63505   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63506   Dali::PinchGestureDetector result;
63507
63508   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63509   {
63510     try {
63511       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPinchGestureDetector();
63512     } catch (std::out_of_range& e) {
63513       {
63514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63515       };
63516     } catch (std::exception& e) {
63517       {
63518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63519       };
63520     } catch (Dali::DaliException e) {
63521       {
63522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63523       };
63524     } catch (...) {
63525       {
63526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63527       };
63528     }
63529   }
63530
63531   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
63532   return jresult;
63533 }
63534
63535
63536 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPanGestureDetector(void * jarg1) {
63537   void * jresult ;
63538   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63539   Dali::PanGestureDetector result;
63540
63541   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63542   {
63543     try {
63544       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPanGestureDetector();
63545     } catch (std::out_of_range& e) {
63546       {
63547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63548       };
63549     } catch (std::exception& e) {
63550       {
63551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63552       };
63553     } catch (Dali::DaliException e) {
63554       {
63555         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63556       };
63557     } catch (...) {
63558       {
63559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63560       };
63561     }
63562   }
63563
63564   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
63565   return jresult;
63566 }
63567
63568
63569 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetTapGestureDetector(void * jarg1) {
63570   void * jresult ;
63571   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63572   Dali::TapGestureDetector result;
63573
63574   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63575   {
63576     try {
63577       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetTapGestureDetector();
63578     } catch (std::out_of_range& e) {
63579       {
63580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63581       };
63582     } catch (std::exception& e) {
63583       {
63584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63585       };
63586     } catch (Dali::DaliException e) {
63587       {
63588         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63589       };
63590     } catch (...) {
63591       {
63592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63593       };
63594     }
63595   }
63596
63597   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
63598   return jresult;
63599 }
63600
63601
63602 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetLongPressGestureDetector(void * jarg1) {
63603   void * jresult ;
63604   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63605   Dali::LongPressGestureDetector result;
63606
63607   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63608   {
63609     try {
63610       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetLongPressGestureDetector();
63611     } catch (std::out_of_range& e) {
63612       {
63613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63614       };
63615     } catch (std::exception& e) {
63616       {
63617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63618       };
63619     } catch (Dali::DaliException e) {
63620       {
63621         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63622       };
63623     } catch (...) {
63624       {
63625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63626       };
63627     }
63628   }
63629
63630   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
63631   return jresult;
63632 }
63633
63634
63635 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyboardNavigationSupport(void * jarg1, unsigned int jarg2) {
63636   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63637   bool arg2 ;
63638
63639   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63640   arg2 = jarg2 ? true : false;
63641   {
63642     try {
63643       (arg1)->SetKeyboardNavigationSupport(arg2);
63644     } catch (std::out_of_range& e) {
63645       {
63646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63647       };
63648     } catch (std::exception& e) {
63649       {
63650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63651       };
63652     } catch (Dali::DaliException e) {
63653       {
63654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63655       };
63656     } catch (...) {
63657       {
63658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63659       };
63660     }
63661   }
63662
63663 }
63664
63665
63666 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardNavigationSupported(void * jarg1) {
63667   unsigned int jresult ;
63668   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63669   bool result;
63670
63671   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63672   {
63673     try {
63674       result = (bool)(arg1)->IsKeyboardNavigationSupported();
63675     } catch (std::out_of_range& e) {
63676       {
63677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63678       };
63679     } catch (std::exception& e) {
63680       {
63681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63682       };
63683     } catch (Dali::DaliException e) {
63684       {
63685         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63686       };
63687     } catch (...) {
63688       {
63689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63690       };
63691     }
63692   }
63693
63694   jresult = result;
63695   return jresult;
63696 }
63697
63698
63699 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyInputFocus(void * jarg1) {
63700   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63701
63702   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63703   {
63704     try {
63705       (arg1)->SetKeyInputFocus();
63706     } catch (std::out_of_range& e) {
63707       {
63708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63709       };
63710     } catch (std::exception& e) {
63711       {
63712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63713       };
63714     } catch (Dali::DaliException e) {
63715       {
63716         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63717       };
63718     } catch (...) {
63719       {
63720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63721       };
63722     }
63723   }
63724
63725 }
63726
63727
63728 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_HasKeyInputFocus(void * jarg1) {
63729   unsigned int jresult ;
63730   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63731   bool result;
63732
63733   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63734   {
63735     try {
63736       result = (bool)(arg1)->HasKeyInputFocus();
63737     } catch (std::out_of_range& e) {
63738       {
63739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63740       };
63741     } catch (std::exception& e) {
63742       {
63743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63744       };
63745     } catch (Dali::DaliException e) {
63746       {
63747         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63748       };
63749     } catch (...) {
63750       {
63751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63752       };
63753     }
63754   }
63755
63756   jresult = result;
63757   return jresult;
63758 }
63759
63760
63761 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearKeyInputFocus(void * jarg1) {
63762   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63763
63764   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63765   {
63766     try {
63767       (arg1)->ClearKeyInputFocus();
63768     } catch (std::out_of_range& e) {
63769       {
63770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63771       };
63772     } catch (std::exception& e) {
63773       {
63774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63775       };
63776     } catch (Dali::DaliException e) {
63777       {
63778         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63779       };
63780     } catch (...) {
63781       {
63782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63783       };
63784     }
63785   }
63786
63787 }
63788
63789
63790 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetAsKeyboardFocusGroup(void * jarg1, unsigned int jarg2) {
63791   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63792   bool arg2 ;
63793
63794   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63795   arg2 = jarg2 ? true : false;
63796   {
63797     try {
63798       (arg1)->SetAsKeyboardFocusGroup(arg2);
63799     } catch (std::out_of_range& e) {
63800       {
63801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63802       };
63803     } catch (std::exception& e) {
63804       {
63805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63806       };
63807     } catch (Dali::DaliException e) {
63808       {
63809         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63810       };
63811     } catch (...) {
63812       {
63813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63814       };
63815     }
63816   }
63817
63818 }
63819
63820
63821 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardFocusGroup(void * jarg1) {
63822   unsigned int jresult ;
63823   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63824   bool result;
63825
63826   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63827   {
63828     try {
63829       result = (bool)(arg1)->IsKeyboardFocusGroup();
63830     } catch (std::out_of_range& e) {
63831       {
63832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63833       };
63834     } catch (std::exception& e) {
63835       {
63836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63837       };
63838     } catch (Dali::DaliException e) {
63839       {
63840         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63841       };
63842     } catch (...) {
63843       {
63844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63845       };
63846     }
63847   }
63848
63849   jresult = result;
63850   return jresult;
63851 }
63852
63853
63854 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyEventSignal(void * jarg1) {
63855   void * jresult ;
63856   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63857   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
63858
63859   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63860   {
63861     try {
63862       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
63863     } catch (std::out_of_range& e) {
63864       {
63865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63866       };
63867     } catch (std::exception& e) {
63868       {
63869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63870       };
63871     } catch (Dali::DaliException e) {
63872       {
63873         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63874       };
63875     } catch (...) {
63876       {
63877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63878       };
63879     }
63880   }
63881
63882   jresult = (void *)result;
63883   return jresult;
63884 }
63885
63886
63887 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusGainedSignal(void * jarg1) {
63888   void * jresult ;
63889   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63890   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
63891
63892   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63893   {
63894     try {
63895       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
63896     } catch (std::out_of_range& e) {
63897       {
63898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63899       };
63900     } catch (std::exception& e) {
63901       {
63902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63903       };
63904     } catch (Dali::DaliException e) {
63905       {
63906         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63907       };
63908     } catch (...) {
63909       {
63910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63911       };
63912     }
63913   }
63914
63915   jresult = (void *)result;
63916   return jresult;
63917 }
63918
63919
63920 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusLostSignal(void * jarg1) {
63921   void * jresult ;
63922   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63923   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
63924
63925   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63926   {
63927     try {
63928       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
63929     } catch (std::out_of_range& e) {
63930       {
63931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63932       };
63933     } catch (std::exception& e) {
63934       {
63935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63936       };
63937     } catch (Dali::DaliException e) {
63938       {
63939         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63940       };
63941     } catch (...) {
63942       {
63943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63944       };
63945     }
63946   }
63947
63948   jresult = (void *)result;
63949   return jresult;
63950 }
63951
63952
63953 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageConnection(void * jarg1, int jarg2) {
63954   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63955   int arg2 ;
63956   SwigDirector_ViewImpl *darg = 0;
63957
63958   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63959   arg2 = (int)jarg2;
63960   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63961   if(!darg) {
63962     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63963     return;
63964   }
63965   {
63966     try {
63967       if(darg) {
63968         (darg)->OnStageConnection(arg2);
63969       }
63970     } catch (std::out_of_range& e) {
63971       {
63972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63973       };
63974     } catch (std::exception& e) {
63975       {
63976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63977       };
63978     } catch (Dali::DaliException e) {
63979       {
63980         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63981       };
63982     } catch (...) {
63983       {
63984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63985       };
63986     }
63987   }
63988
63989 }
63990
63991
63992 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageConnectionSwigExplicitViewImpl(void * jarg1, int jarg2) {
63993   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63994   int arg2 ;
63995   SwigDirector_ViewImpl *darg = 0;
63996
63997   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63998   arg2 = (int)jarg2;
63999   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64000   if(!darg) {
64001     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64002     return;
64003   }
64004   {
64005     try {
64006       if(darg) {
64007         (darg)->OnStageConnectionSwigPublic(arg2);
64008       }
64009     } catch (std::out_of_range& e) {
64010       {
64011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64012       };
64013     } catch (std::exception& e) {
64014       {
64015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64016       };
64017     } catch (Dali::DaliException e) {
64018       {
64019         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64020       };
64021     } catch (...) {
64022       {
64023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64024       };
64025     }
64026   }
64027
64028 }
64029
64030
64031 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageDisconnection(void * jarg1) {
64032   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64033   SwigDirector_ViewImpl *darg = 0;
64034
64035   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64036   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64037   if(!darg) {
64038     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64039     return;
64040   }
64041   {
64042     try {
64043       if(darg) {
64044         (darg)->OnStageDisconnection();
64045       }
64046     } catch (std::out_of_range& e) {
64047       {
64048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64049       };
64050     } catch (std::exception& e) {
64051       {
64052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64053       };
64054     } catch (Dali::DaliException e) {
64055       {
64056         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64057       };
64058     } catch (...) {
64059       {
64060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64061       };
64062     }
64063   }
64064
64065 }
64066
64067
64068 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageDisconnectionSwigExplicitViewImpl(void * jarg1) {
64069   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64070   SwigDirector_ViewImpl *darg = 0;
64071
64072   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64073   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64074   if(!darg) {
64075     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64076     return;
64077   }
64078   {
64079     try {
64080       if(darg) {
64081         (darg)->OnStageDisconnectionSwigPublic();
64082       }
64083     } catch (std::out_of_range& e) {
64084       {
64085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64086       };
64087     } catch (std::exception& e) {
64088       {
64089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64090       };
64091     } catch (Dali::DaliException e) {
64092       {
64093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64094       };
64095     } catch (...) {
64096       {
64097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64098       };
64099     }
64100   }
64101
64102 }
64103
64104
64105 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAdd(void * jarg1, void * jarg2) {
64106   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64107   Dali::Actor *arg2 = 0 ;
64108   SwigDirector_ViewImpl *darg = 0;
64109
64110   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64111   arg2 = (Dali::Actor *)jarg2;
64112   if (!arg2) {
64113     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
64114     return ;
64115   }
64116   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64117   if(!darg) {
64118     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64119     return;
64120   }
64121   {
64122     try {
64123       if(darg) {
64124         (darg)->OnChildAdd(*arg2);
64125       }
64126     } catch (std::out_of_range& e) {
64127       {
64128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64129       };
64130     } catch (std::exception& e) {
64131       {
64132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64133       };
64134     } catch (Dali::DaliException e) {
64135       {
64136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64137       };
64138     } catch (...) {
64139       {
64140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64141       };
64142     }
64143   }
64144
64145 }
64146
64147
64148 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64149   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64150   Dali::Actor *arg2 = 0 ;
64151   SwigDirector_ViewImpl *darg = 0;
64152
64153   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64154   arg2 = (Dali::Actor *)jarg2;
64155   if (!arg2) {
64156     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
64157     return ;
64158   }
64159   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64160   if(!darg) {
64161     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64162     return;
64163   }
64164   {
64165     try {
64166       if(darg) {
64167           (darg)->OnChildAddSwigPublic(*arg2);
64168       }
64169     } catch (std::out_of_range& e) {
64170       {
64171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64172       };
64173     } catch (std::exception& e) {
64174       {
64175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64176       };
64177     } catch (Dali::DaliException e) {
64178       {
64179         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64180       };
64181     } catch (...) {
64182       {
64183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64184       };
64185     }
64186   }
64187
64188 }
64189
64190
64191 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemove(void * jarg1, void * jarg2) {
64192   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64193   Dali::Actor *arg2 = 0 ;
64194   SwigDirector_ViewImpl *darg = 0;
64195
64196   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64197   arg2 = (Dali::Actor *)jarg2;
64198   if (!arg2) {
64199     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
64200     return ;
64201   }
64202   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64203   if(!darg) {
64204     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64205     return;
64206   }
64207   {
64208     try {
64209       if(darg) {
64210         (darg)->OnChildRemove(*arg2);
64211       }
64212     } catch (std::out_of_range& e) {
64213       {
64214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64215       };
64216     } catch (std::exception& e) {
64217       {
64218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64219       };
64220     } catch (Dali::DaliException e) {
64221       {
64222         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64223       };
64224     } catch (...) {
64225       {
64226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64227       };
64228     }
64229   }
64230
64231 }
64232
64233
64234 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64235   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64236   Dali::Actor *arg2 = 0 ;
64237   SwigDirector_ViewImpl *darg = 0;
64238
64239   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64240   arg2 = (Dali::Actor *)jarg2;
64241   if (!arg2) {
64242     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
64243     return ;
64244   }
64245   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64246   if(!darg) {
64247     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64248     return;
64249   }
64250   {
64251     try {
64252       if(darg) {
64253         (darg)->OnChildRemoveSwigPublic(*arg2);
64254       }
64255     } catch (std::out_of_range& e) {
64256       {
64257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64258       };
64259     } catch (std::exception& e) {
64260       {
64261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64262       };
64263     } catch (Dali::DaliException e) {
64264       {
64265         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64266       };
64267     } catch (...) {
64268       {
64269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64270       };
64271     }
64272   }
64273
64274 }
64275
64276
64277 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
64278   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64279   Dali::Property::Index arg2 ;
64280   Dali::Property::Value arg3 ;
64281   Dali::Property::Value *argp3 ;
64282   SwigDirector_ViewImpl *darg = 0;
64283
64284   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64285   arg2 = (Dali::Property::Index)jarg2;
64286   argp3 = (Dali::Property::Value *)jarg3;
64287   if (!argp3) {
64288     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
64289     return ;
64290   }
64291   arg3 = *argp3;
64292   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64293   if (!darg) {
64294     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64295     return;
64296   }
64297   {
64298     try {
64299       (darg)->OnPropertySet(arg2,arg3);
64300     } catch (std::out_of_range& e) {
64301       {
64302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64303       };
64304     } catch (std::exception& e) {
64305       {
64306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64307       };
64308     } catch (Dali::DaliException e) {
64309       {
64310         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64311       };
64312     } catch (...) {
64313       {
64314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64315       };
64316     }
64317   }
64318
64319 }
64320
64321
64322 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySetSwigExplicitViewImpl(void * jarg1, int jarg2, void * jarg3) {
64323   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64324   Dali::Property::Index arg2 ;
64325   Dali::Property::Value arg3 ;
64326   Dali::Property::Value *argp3 ;
64327   SwigDirector_ViewImpl *darg = 0;
64328
64329   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64330   arg2 = (Dali::Property::Index)jarg2;
64331   argp3 = (Dali::Property::Value *)jarg3;
64332   if (!argp3) {
64333     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
64334     return ;
64335   }
64336   arg3 = *argp3;
64337   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64338   if (!darg) {
64339     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64340     return;
64341   }
64342   {
64343     try {
64344       (darg)->OnPropertySetSwigPublic(arg2,arg3);
64345     } catch (std::out_of_range& e) {
64346       {
64347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64348       };
64349     } catch (std::exception& e) {
64350       {
64351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64352       };
64353     } catch (Dali::DaliException e) {
64354       {
64355         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64356       };
64357     } catch (...) {
64358       {
64359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64360       };
64361     }
64362   }
64363
64364 }
64365
64366
64367 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSet(void * jarg1, void * jarg2) {
64368   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64369   Dali::Vector3 *arg2 = 0 ;
64370   SwigDirector_ViewImpl *darg = 0;
64371
64372   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64373   arg2 = (Dali::Vector3 *)jarg2;
64374   if (!arg2) {
64375     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64376     return ;
64377   }
64378   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64379   if (!darg) {
64380     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64381     return;
64382   }
64383   {
64384     try {
64385       (darg)->OnSizeSet((Dali::Vector3 const &)*arg2);
64386     } catch (std::out_of_range& e) {
64387       {
64388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64389       };
64390     } catch (std::exception& e) {
64391       {
64392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64393       };
64394     } catch (Dali::DaliException e) {
64395       {
64396         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64397       };
64398     } catch (...) {
64399       {
64400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64401       };
64402     }
64403   }
64404
64405 }
64406
64407
64408 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSetSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64409   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64410   Dali::Vector3 *arg2 = 0 ;
64411   SwigDirector_ViewImpl *darg = 0;
64412
64413   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64414   arg2 = (Dali::Vector3 *)jarg2;
64415   if (!arg2) {
64416     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64417     return ;
64418   }
64419   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64420   if (!darg) {
64421     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64422     return;
64423   }
64424   {
64425     try {
64426       (darg)->OnSizeSetSwigPublic((Dali::Vector3 const &)*arg2);
64427     } catch (std::out_of_range& e) {
64428       {
64429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64430       };
64431     } catch (std::exception& e) {
64432       {
64433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64434       };
64435     } catch (Dali::DaliException e) {
64436       {
64437         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64438       };
64439     } catch (...) {
64440       {
64441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64442       };
64443     }
64444   }
64445
64446 }
64447
64448
64449 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
64450   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64451   Dali::Animation *arg2 = 0 ;
64452   Dali::Vector3 *arg3 = 0 ;
64453   SwigDirector_ViewImpl *darg = 0;
64454
64455   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64456   arg2 = (Dali::Animation *)jarg2;
64457   if (!arg2) {
64458     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
64459     return ;
64460   }
64461   arg3 = (Dali::Vector3 *)jarg3;
64462   if (!arg3) {
64463     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64464     return ;
64465   }
64466   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64467   if (!darg) {
64468     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64469     return;
64470   }
64471   {
64472     try {
64473       (darg)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
64474     } catch (std::out_of_range& e) {
64475       {
64476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64477       };
64478     } catch (std::exception& e) {
64479       {
64480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64481       };
64482     } catch (Dali::DaliException e) {
64483       {
64484         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64485       };
64486     } catch (...) {
64487       {
64488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64489       };
64490     }
64491   }
64492
64493 }
64494
64495
64496 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimationSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
64497   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64498   Dali::Animation *arg2 = 0 ;
64499   Dali::Vector3 *arg3 = 0 ;
64500   SwigDirector_ViewImpl *darg = 0;
64501
64502   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64503   arg2 = (Dali::Animation *)jarg2;
64504   if (!arg2) {
64505     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
64506     return ;
64507   }
64508   arg3 = (Dali::Vector3 *)jarg3;
64509   if (!arg3) {
64510     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64511     return ;
64512   }
64513   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64514   if (!darg) {
64515     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64516     return;
64517   }
64518   {
64519     try {
64520       (darg)->OnSizeAnimationSwigPublic(*arg2,(Dali::Vector3 const &)*arg3);
64521     } catch (std::out_of_range& e) {
64522       {
64523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64524       };
64525     } catch (std::exception& e) {
64526       {
64527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64528       };
64529     } catch (Dali::DaliException e) {
64530       {
64531         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64532       };
64533     } catch (...) {
64534       {
64535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64536       };
64537     }
64538   }
64539
64540 }
64541
64542
64543 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEvent(void * jarg1, void * jarg2) {
64544   unsigned int jresult ;
64545   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64546   Dali::TouchEvent *arg2 = 0 ;
64547   SwigDirector_ViewImpl *darg = 0;
64548   bool result;
64549
64550   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64551   arg2 = (Dali::TouchEvent *)jarg2;
64552   if (!arg2) {
64553     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
64554     return 0;
64555   }
64556   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64557   if (!darg) {
64558     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64559     return 0;
64560   }
64561   {
64562     try {
64563       result = (bool)(darg)->OnTouchEvent((Dali::TouchEvent const &)*arg2);
64564     } catch (std::out_of_range& e) {
64565       {
64566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64567       };
64568     } catch (std::exception& e) {
64569       {
64570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64571       };
64572     } catch (Dali::DaliException e) {
64573       {
64574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64575       };
64576     } catch (...) {
64577       {
64578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64579       };
64580     }
64581   }
64582
64583   jresult = result;
64584   return jresult;
64585 }
64586
64587
64588 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64589   unsigned int jresult ;
64590   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64591   Dali::TouchEvent *arg2 = 0 ;
64592   SwigDirector_ViewImpl *darg = 0;
64593   bool result;
64594
64595   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64596   arg2 = (Dali::TouchEvent *)jarg2;
64597   if (!arg2) {
64598     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
64599     return 0;
64600   }
64601   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64602   if (!darg) {
64603     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64604     return 0;
64605   }
64606   {
64607     try {
64608       result = (bool)(darg)->OnTouchEventSwigPublic((Dali::TouchEvent const &)*arg2);
64609     } catch (std::out_of_range& e) {
64610       {
64611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64612       };
64613     } catch (std::exception& e) {
64614       {
64615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64616       };
64617     } catch (Dali::DaliException e) {
64618       {
64619         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64620       };
64621     } catch (...) {
64622       {
64623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64624       };
64625     }
64626   }
64627
64628   jresult = result;
64629   return jresult;
64630 }
64631
64632
64633 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEvent(void * jarg1, void * jarg2) {
64634   unsigned int jresult ;
64635   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64636   Dali::HoverEvent *arg2 = 0 ;
64637   SwigDirector_ViewImpl *darg = 0;
64638   bool result;
64639
64640   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64641   arg2 = (Dali::HoverEvent *)jarg2;
64642   if (!arg2) {
64643     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
64644     return 0;
64645   }
64646   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64647   if (!darg) {
64648     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64649     return 0;
64650   }
64651   {
64652     try {
64653       result = (bool)(darg)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
64654     } catch (std::out_of_range& e) {
64655       {
64656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64657       };
64658     } catch (std::exception& e) {
64659       {
64660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64661       };
64662     } catch (Dali::DaliException e) {
64663       {
64664         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64665       };
64666     } catch (...) {
64667       {
64668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64669       };
64670     }
64671   }
64672
64673   jresult = result;
64674   return jresult;
64675 }
64676
64677
64678 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64679   unsigned int jresult ;
64680   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64681   Dali::HoverEvent *arg2 = 0 ;
64682   SwigDirector_ViewImpl *darg = 0;
64683   bool result;
64684
64685   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64686   arg2 = (Dali::HoverEvent *)jarg2;
64687   if (!arg2) {
64688     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
64689     return 0;
64690   }
64691   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64692   if (!darg) {
64693     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64694     return 0;
64695   }
64696   {
64697     try {
64698       result = (bool)(darg)->OnHoverEventSwigPublic((Dali::HoverEvent const &)*arg2);
64699     } catch (std::out_of_range& e) {
64700       {
64701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64702       };
64703     } catch (std::exception& e) {
64704       {
64705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64706       };
64707     } catch (Dali::DaliException e) {
64708       {
64709         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64710       };
64711     } catch (...) {
64712       {
64713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64714       };
64715     }
64716   }
64717
64718   jresult = result;
64719   return jresult;
64720 }
64721
64722
64723 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEvent(void * jarg1, void * jarg2) {
64724   unsigned int jresult ;
64725   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64726   Dali::KeyEvent *arg2 = 0 ;
64727   SwigDirector_ViewImpl *darg = 0;
64728   bool result;
64729
64730   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64731   arg2 = (Dali::KeyEvent *)jarg2;
64732   if (!arg2) {
64733     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
64734     return 0;
64735   }
64736   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64737   if (!darg) {
64738     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64739     return 0;
64740   }
64741   {
64742     try {
64743       result = (bool)(darg)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
64744     } catch (std::out_of_range& e) {
64745       {
64746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64747       };
64748     } catch (std::exception& e) {
64749       {
64750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64751       };
64752     } catch (Dali::DaliException e) {
64753       {
64754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64755       };
64756     } catch (...) {
64757       {
64758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64759       };
64760     }
64761   }
64762
64763   jresult = result;
64764   return jresult;
64765 }
64766
64767
64768 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64769   unsigned int jresult ;
64770   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64771   Dali::KeyEvent *arg2 = 0 ;
64772   SwigDirector_ViewImpl *darg = 0;
64773   bool result;
64774
64775   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64776   arg2 = (Dali::KeyEvent *)jarg2;
64777   if (!arg2) {
64778     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
64779     return 0;
64780   }
64781   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64782   if (!darg) {
64783     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64784     return 0;
64785   }
64786   {
64787     try {
64788       result = (bool)(darg)->OnKeyEventSwigPublic((Dali::KeyEvent const &)*arg2);
64789     } catch (std::out_of_range& e) {
64790       {
64791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64792       };
64793     } catch (std::exception& e) {
64794       {
64795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64796       };
64797     } catch (Dali::DaliException e) {
64798       {
64799         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64800       };
64801     } catch (...) {
64802       {
64803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64804       };
64805     }
64806   }
64807
64808   jresult = result;
64809   return jresult;
64810 }
64811
64812
64813 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEvent(void * jarg1, void * jarg2) {
64814   unsigned int jresult ;
64815   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64816   Dali::WheelEvent *arg2 = 0 ;
64817   SwigDirector_ViewImpl *darg = 0;
64818   bool result;
64819
64820   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64821   arg2 = (Dali::WheelEvent *)jarg2;
64822   if (!arg2) {
64823     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
64824     return 0;
64825   }
64826   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64827   if (!darg) {
64828     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64829     return 0;
64830   }
64831   {
64832     try {
64833       result = (bool)(darg)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
64834     } catch (std::out_of_range& e) {
64835       {
64836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64837       };
64838     } catch (std::exception& e) {
64839       {
64840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64841       };
64842     } catch (Dali::DaliException e) {
64843       {
64844         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64845       };
64846     } catch (...) {
64847       {
64848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64849       };
64850     }
64851   }
64852
64853   jresult = result;
64854   return jresult;
64855 }
64856
64857
64858 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64859   unsigned int jresult ;
64860   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64861   Dali::WheelEvent *arg2 = 0 ;
64862   SwigDirector_ViewImpl *darg = 0;
64863   bool result;
64864
64865   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64866   arg2 = (Dali::WheelEvent *)jarg2;
64867   if (!arg2) {
64868     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
64869     return 0;
64870   }
64871   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64872   if (!darg) {
64873     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64874     return 0;
64875   }
64876   {
64877     try {
64878       result = (bool)(darg)->OnWheelEventSwigPublic((Dali::WheelEvent const &)*arg2);
64879     } catch (std::out_of_range& e) {
64880       {
64881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64882       };
64883     } catch (std::exception& e) {
64884       {
64885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64886       };
64887     } catch (Dali::DaliException e) {
64888       {
64889         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64890       };
64891     } catch (...) {
64892       {
64893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64894       };
64895     }
64896   }
64897
64898   jresult = result;
64899   return jresult;
64900 }
64901
64902
64903 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
64904   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64905   Dali::Vector2 *arg2 = 0 ;
64906   Dali::RelayoutContainer *arg3 = 0 ;
64907   SwigDirector_ViewImpl *darg = 0;
64908
64909   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64910   arg2 = (Dali::Vector2 *)jarg2;
64911   if (!arg2) {
64912     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
64913     return ;
64914   }
64915   arg3 = (Dali::RelayoutContainer *)jarg3;
64916   if (!arg3) {
64917     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
64918     return ;
64919   }
64920   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64921   if (!darg) {
64922     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64923     return;
64924   }
64925   {
64926     try {
64927       (darg)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
64928     } catch (std::out_of_range& e) {
64929       {
64930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64931       };
64932     } catch (std::exception& e) {
64933       {
64934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64935       };
64936     } catch (Dali::DaliException e) {
64937       {
64938         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64939       };
64940     } catch (...) {
64941       {
64942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64943       };
64944     }
64945   }
64946
64947 }
64948
64949
64950 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayoutSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
64951   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64952   Dali::Vector2 *arg2 = 0 ;
64953   Dali::RelayoutContainer *arg3 = 0 ;
64954   SwigDirector_ViewImpl *darg = 0;
64955
64956   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64957   arg2 = (Dali::Vector2 *)jarg2;
64958   if (!arg2) {
64959     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
64960     return ;
64961   }
64962   arg3 = (Dali::RelayoutContainer *)jarg3;
64963   if (!arg3) {
64964     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
64965     return ;
64966   }
64967   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64968   if (!darg) {
64969     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64970     return;
64971   }
64972   {
64973     try {
64974       (darg)->OnRelayoutSwigPublic((Dali::Vector2 const &)*arg2,*arg3);
64975     } catch (std::out_of_range& e) {
64976       {
64977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64978       };
64979     } catch (std::exception& e) {
64980       {
64981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64982       };
64983     } catch (Dali::DaliException e) {
64984       {
64985         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64986       };
64987     } catch (...) {
64988       {
64989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64990       };
64991     }
64992   }
64993
64994 }
64995
64996
64997 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
64998   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64999   Dali::ResizePolicy::Type arg2 ;
65000   Dali::Dimension::Type arg3 ;
65001   SwigDirector_ViewImpl *darg = 0;
65002
65003   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65004   arg2 = (Dali::ResizePolicy::Type)jarg2;
65005   arg3 = (Dali::Dimension::Type)jarg3;
65006   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65007   if (!darg) {
65008     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65009     return;
65010   }
65011   {
65012     try {
65013       (darg)->OnSetResizePolicy(arg2,arg3);
65014     } catch (std::out_of_range& e) {
65015       {
65016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65017       };
65018     } catch (std::exception& e) {
65019       {
65020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65021       };
65022     } catch (Dali::DaliException e) {
65023       {
65024         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65025       };
65026     } catch (...) {
65027       {
65028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65029       };
65030     }
65031   }
65032
65033 }
65034
65035
65036 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicySwigExplicitViewImpl(void * jarg1, int jarg2, int jarg3) {
65037   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65038   Dali::ResizePolicy::Type arg2 ;
65039   Dali::Dimension::Type arg3 ;
65040   SwigDirector_ViewImpl *darg = 0;
65041
65042   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65043   arg2 = (Dali::ResizePolicy::Type)jarg2;
65044   arg3 = (Dali::Dimension::Type)jarg3;
65045   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65046   if (!darg) {
65047     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65048     return;
65049   }
65050   {
65051     try {
65052       (darg)->OnSetResizePolicySwigPublic(arg2,arg3);
65053     } catch (std::out_of_range& e) {
65054       {
65055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65056       };
65057     } catch (std::exception& e) {
65058       {
65059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65060       };
65061     } catch (Dali::DaliException e) {
65062       {
65063         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65064       };
65065     } catch (...) {
65066       {
65067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65068       };
65069     }
65070   }
65071
65072 }
65073
65074
65075 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSize(void * jarg1) {
65076   void * jresult ;
65077   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65078   SwigDirector_ViewImpl *darg = 0;
65079   Dali::Vector3 result;
65080
65081   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65082   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65083   if (!darg) {
65084     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65085     return 0;
65086   }
65087   {
65088     try {
65089       result = (darg)->GetNaturalSize();
65090     } catch (std::out_of_range& e) {
65091       {
65092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65093       };
65094     } catch (std::exception& e) {
65095       {
65096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65097       };
65098     } catch (Dali::DaliException e) {
65099       {
65100         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65101       };
65102     } catch (...) {
65103       {
65104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65105       };
65106     }
65107   }
65108
65109   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
65110   return jresult;
65111 }
65112
65113
65114 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSizeSwigExplicitViewImpl(void * jarg1) {
65115   void * jresult ;
65116   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65117   SwigDirector_ViewImpl *darg = 0;
65118   Dali::Vector3 result;
65119
65120   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65121   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65122   if (!darg) {
65123     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65124     return 0;
65125   }
65126   {
65127     try {
65128       result = (darg)->GetNaturalSizeSwigPublic();
65129     } catch (std::out_of_range& e) {
65130       {
65131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65132       };
65133     } catch (std::exception& e) {
65134       {
65135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65136       };
65137     } catch (Dali::DaliException e) {
65138       {
65139         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65140       };
65141     } catch (...) {
65142       {
65143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65144       };
65145     }
65146   }
65147
65148   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
65149   return jresult;
65150 }
65151
65152
65153 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
65154   float jresult ;
65155   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65156   Dali::Actor *arg2 = 0 ;
65157   Dali::Dimension::Type arg3 ;
65158   SwigDirector_ViewImpl *darg = 0;
65159   float result;
65160
65161   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65162   arg2 = (Dali::Actor *)jarg2;
65163   if (!arg2) {
65164     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
65165     return 0;
65166   }
65167   arg3 = (Dali::Dimension::Type)jarg3;
65168   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65169   if (!darg) {
65170     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65171     return 0;
65172   }
65173   {
65174     try {
65175       result = (float)(darg)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
65176     } catch (std::out_of_range& e) {
65177       {
65178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65179       };
65180     } catch (std::exception& e) {
65181       {
65182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65183       };
65184     } catch (Dali::DaliException e) {
65185       {
65186         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65187       };
65188     } catch (...) {
65189       {
65190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65191       };
65192     }
65193   }
65194
65195   jresult = result;
65196   return jresult;
65197 }
65198
65199
65200 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSizeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
65201   float jresult ;
65202   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65203   Dali::Actor *arg2 = 0 ;
65204   Dali::Dimension::Type arg3 ;
65205   SwigDirector_ViewImpl *darg = 0;
65206   float result;
65207
65208   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65209   arg2 = (Dali::Actor *)jarg2;
65210   if (!arg2) {
65211     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
65212     return 0;
65213   }
65214   arg3 = (Dali::Dimension::Type)jarg3;
65215   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65216   if (!darg) {
65217     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65218     return 0;
65219   }
65220   {
65221     try {
65222       result = (float)(darg)->CalculateChildSizeSwigPublic((Dali::Actor const &)*arg2,arg3);
65223     } catch (std::out_of_range& e) {
65224       {
65225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65226       };
65227     } catch (std::exception& e) {
65228       {
65229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65230       };
65231     } catch (Dali::DaliException e) {
65232       {
65233         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65234       };
65235     } catch (...) {
65236       {
65237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65238       };
65239     }
65240   }
65241
65242   jresult = result;
65243   return jresult;
65244 }
65245
65246
65247 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidth(void * jarg1, float jarg2) {
65248   float jresult ;
65249   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65250   float arg2 ;
65251   SwigDirector_ViewImpl *darg = 0;
65252   float result;
65253
65254   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65255   arg2 = (float)jarg2;
65256   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65257   if (!darg) {
65258     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65259     return 0;
65260   }
65261   {
65262     try {
65263       result = (float)(darg)->GetHeightForWidth(arg2);
65264     } catch (std::out_of_range& e) {
65265       {
65266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65267       };
65268     } catch (std::exception& e) {
65269       {
65270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65271       };
65272     } catch (Dali::DaliException e) {
65273       {
65274         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65275       };
65276     } catch (...) {
65277       {
65278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65279       };
65280     }
65281   }
65282
65283   jresult = result;
65284   return jresult;
65285 }
65286
65287
65288 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidthSwigExplicitViewImpl(void * jarg1, float jarg2) {
65289   float jresult ;
65290   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65291   float arg2 ;
65292   SwigDirector_ViewImpl *darg = 0;
65293   float result;
65294
65295   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65296   arg2 = (float)jarg2;
65297   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65298   if (!darg) {
65299     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65300     return 0;
65301   }
65302   {
65303     try {
65304       result = (float)(darg)->GetHeightForWidthSwigPublic(arg2);
65305     } catch (std::out_of_range& e) {
65306       {
65307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65308       };
65309     } catch (std::exception& e) {
65310       {
65311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65312       };
65313     } catch (Dali::DaliException e) {
65314       {
65315         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65316       };
65317     } catch (...) {
65318       {
65319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65320       };
65321     }
65322   }
65323
65324   jresult = result;
65325   return jresult;
65326 }
65327
65328
65329 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeight(void * jarg1, float jarg2) {
65330   float jresult ;
65331   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65332   float arg2 ;
65333   SwigDirector_ViewImpl *darg = 0;
65334   float result;
65335
65336   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65337   arg2 = (float)jarg2;
65338   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65339   if (!darg) {
65340     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65341     return 0;
65342   }
65343   {
65344     try {
65345       result = (float)(darg)->GetWidthForHeight(arg2);
65346     } catch (std::out_of_range& e) {
65347       {
65348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65349       };
65350     } catch (std::exception& e) {
65351       {
65352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65353       };
65354     } catch (Dali::DaliException e) {
65355       {
65356         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65357       };
65358     } catch (...) {
65359       {
65360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65361       };
65362     }
65363   }
65364
65365   jresult = result;
65366   return jresult;
65367 }
65368
65369
65370 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeightSwigExplicitViewImpl(void * jarg1, float jarg2) {
65371   float jresult ;
65372   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65373   float arg2 ;
65374   SwigDirector_ViewImpl *darg = 0;
65375   float result;
65376
65377   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65378   arg2 = (float)jarg2;
65379   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65380   if (!darg) {
65381     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65382     return 0;
65383   }
65384   {
65385     try {
65386       result = (float)(darg)->GetWidthForHeightSwigPublic(arg2);
65387     } catch (std::out_of_range& e) {
65388       {
65389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65390       };
65391     } catch (std::exception& e) {
65392       {
65393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65394       };
65395     } catch (Dali::DaliException e) {
65396       {
65397         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65398       };
65399     } catch (...) {
65400       {
65401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65402       };
65403     }
65404   }
65405
65406   jresult = result;
65407   return jresult;
65408 }
65409
65410
65411 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
65412   unsigned int jresult ;
65413   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65414   Dali::Dimension::Type arg2 ;
65415   SwigDirector_ViewImpl *darg = 0;
65416   bool result;
65417
65418   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65419   arg2 = (Dali::Dimension::Type)jarg2;
65420   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65421   if (!darg) {
65422     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65423     return 0;
65424   }
65425   {
65426     try {
65427       result = (bool)(darg)->RelayoutDependentOnChildren(arg2);
65428     } catch (std::out_of_range& e) {
65429       {
65430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65431       };
65432     } catch (std::exception& e) {
65433       {
65434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65435       };
65436     } catch (Dali::DaliException e) {
65437       {
65438         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65439       };
65440     } catch (...) {
65441       {
65442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65443       };
65444     }
65445   }
65446
65447   jresult = result;
65448   return jresult;
65449 }
65450
65451
65452 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_0(void * jarg1, int jarg2) {
65453   unsigned int jresult ;
65454   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65455   Dali::Dimension::Type arg2 ;
65456   SwigDirector_ViewImpl *darg = 0;
65457   bool result;
65458
65459   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65460   arg2 = (Dali::Dimension::Type)jarg2;
65461   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65462   if (!darg) {
65463     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65464     return 0;
65465   }
65466   {
65467     try {
65468       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic(arg2);
65469     } catch (std::out_of_range& e) {
65470       {
65471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65472       };
65473     } catch (std::exception& e) {
65474       {
65475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65476       };
65477     } catch (Dali::DaliException e) {
65478       {
65479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65480       };
65481     } catch (...) {
65482       {
65483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65484       };
65485     }
65486   }
65487
65488   jresult = result;
65489   return jresult;
65490 }
65491
65492
65493 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
65494   unsigned int jresult ;
65495   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65496   SwigDirector_ViewImpl *darg = 0;
65497   bool result;
65498
65499   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65500   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65501   if (!darg) {
65502     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65503     return 0;
65504   }
65505   {
65506     try {
65507       result = (bool)(darg)->RelayoutDependentOnChildren();
65508     } catch (std::out_of_range& e) {
65509       {
65510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65511       };
65512     } catch (std::exception& e) {
65513       {
65514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65515       };
65516     } catch (Dali::DaliException e) {
65517       {
65518         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65519       };
65520     } catch (...) {
65521       {
65522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65523       };
65524     }
65525   }
65526
65527   jresult = result;
65528   return jresult;
65529 }
65530
65531
65532 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_1(void * jarg1) {
65533   unsigned int jresult ;
65534   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65535   SwigDirector_ViewImpl *darg = 0;
65536   bool result;
65537
65538   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65539   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65540   if (!darg) {
65541     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65542     return 0;
65543   }
65544   {
65545     try {
65546       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic();
65547     } catch (std::out_of_range& e) {
65548       {
65549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65550       };
65551     } catch (std::exception& e) {
65552       {
65553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65554       };
65555     } catch (Dali::DaliException e) {
65556       {
65557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65558       };
65559     } catch (...) {
65560       {
65561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65562       };
65563     }
65564   }
65565
65566   jresult = result;
65567   return jresult;
65568 }
65569
65570
65571 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
65572   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65573   Dali::Dimension::Type arg2 ;
65574   SwigDirector_ViewImpl *darg = 0;
65575
65576   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65577   arg2 = (Dali::Dimension::Type)jarg2;
65578   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65579   if (!darg) {
65580     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65581     return;
65582   }
65583   {
65584     try {
65585       (darg)->OnCalculateRelayoutSize(arg2);
65586     } catch (std::out_of_range& e) {
65587       {
65588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65589       };
65590     } catch (std::exception& e) {
65591       {
65592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65593       };
65594     } catch (Dali::DaliException e) {
65595       {
65596         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65597       };
65598     } catch (...) {
65599       {
65600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65601       };
65602     }
65603   }
65604
65605 }
65606
65607
65608 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSizeSwigExplicitViewImpl(void * jarg1, int jarg2) {
65609   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65610   Dali::Dimension::Type arg2 ;
65611   SwigDirector_ViewImpl *darg = 0;
65612
65613   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65614   arg2 = (Dali::Dimension::Type)jarg2;
65615   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65616   if (!darg) {
65617     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65618     return;
65619   }
65620   {
65621     try {
65622       (darg)->OnCalculateRelayoutSizeSwigPublic(arg2);
65623     } catch (std::out_of_range& e) {
65624       {
65625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65626       };
65627     } catch (std::exception& e) {
65628       {
65629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65630       };
65631     } catch (Dali::DaliException e) {
65632       {
65633         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65634       };
65635     } catch (...) {
65636       {
65637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65638       };
65639     }
65640   }
65641
65642 }
65643
65644
65645 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
65646   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65647   float arg2 ;
65648   Dali::Dimension::Type arg3 ;
65649   SwigDirector_ViewImpl *darg = 0;
65650
65651   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65652   arg2 = (float)jarg2;
65653   arg3 = (Dali::Dimension::Type)jarg3;
65654   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65655   if (!darg) {
65656     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65657     return;
65658   }
65659   {
65660     try {
65661       (darg)->OnLayoutNegotiated(arg2,arg3);
65662     } catch (std::out_of_range& e) {
65663       {
65664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65665       };
65666     } catch (std::exception& e) {
65667       {
65668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65669       };
65670     } catch (Dali::DaliException e) {
65671       {
65672         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65673       };
65674     } catch (...) {
65675       {
65676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65677       };
65678     }
65679   }
65680
65681 }
65682
65683
65684 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiatedSwigExplicitViewImpl(void * jarg1, float jarg2, int jarg3) {
65685   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65686   float arg2 ;
65687   Dali::Dimension::Type arg3 ;
65688   SwigDirector_ViewImpl *darg = 0;
65689
65690   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65691   arg2 = (float)jarg2;
65692   arg3 = (Dali::Dimension::Type)jarg3;
65693   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65694   if (!darg) {
65695     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65696     return;
65697   }
65698   {
65699     try {
65700       (darg)->OnLayoutNegotiatedSwigPublic(arg2,arg3);
65701     } catch (std::out_of_range& e) {
65702       {
65703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65704       };
65705     } catch (std::exception& e) {
65706       {
65707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65708       };
65709     } catch (Dali::DaliException e) {
65710       {
65711         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65712       };
65713     } catch (...) {
65714       {
65715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65716       };
65717     }
65718   }
65719
65720 }
65721
65722
65723 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitialize(void * jarg1) {
65724   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65725
65726   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65727   {
65728     try {
65729       (arg1)->OnInitialize();
65730     } catch (std::out_of_range& e) {
65731       {
65732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65733       };
65734     } catch (std::exception& e) {
65735       {
65736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65737       };
65738     } catch (Dali::DaliException e) {
65739       {
65740         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65741       };
65742     } catch (...) {
65743       {
65744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65745       };
65746     }
65747   }
65748
65749 }
65750
65751
65752 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitializeSwigExplicitViewImpl(void * jarg1) {
65753   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65754
65755   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65756   {
65757     try {
65758       (arg1)->Dali::Toolkit::Internal::Control::OnInitialize();
65759     } catch (std::out_of_range& e) {
65760       {
65761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65762       };
65763     } catch (std::exception& e) {
65764       {
65765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65766       };
65767     } catch (Dali::DaliException e) {
65768       {
65769         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65770       };
65771     } catch (...) {
65772       {
65773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65774       };
65775     }
65776   }
65777
65778 }
65779
65780
65781 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildAdd(void * jarg1, void * jarg2) {
65782   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65783   Dali::Actor *arg2 = 0 ;
65784
65785   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65786   arg2 = (Dali::Actor *)jarg2;
65787   if (!arg2) {
65788     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
65789     return ;
65790   }
65791   {
65792     try {
65793       (arg1)->OnControlChildAdd(*arg2);
65794     } catch (std::out_of_range& e) {
65795       {
65796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65797       };
65798     } catch (std::exception& e) {
65799       {
65800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65801       };
65802     } catch (Dali::DaliException e) {
65803       {
65804         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65805       };
65806     } catch (...) {
65807       {
65808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65809       };
65810     }
65811   }
65812
65813 }
65814
65815
65816 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
65817   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65818   Dali::Actor *arg2 = 0 ;
65819
65820   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65821   arg2 = (Dali::Actor *)jarg2;
65822   if (!arg2) {
65823     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
65824     return ;
65825   }
65826   {
65827     try {
65828       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildAdd(*arg2);
65829     } catch (std::out_of_range& e) {
65830       {
65831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65832       };
65833     } catch (std::exception& e) {
65834       {
65835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65836       };
65837     } catch (Dali::DaliException e) {
65838       {
65839         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65840       };
65841     } catch (...) {
65842       {
65843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65844       };
65845     }
65846   }
65847
65848 }
65849
65850
65851 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildRemove(void * jarg1, void * jarg2) {
65852   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65853   Dali::Actor *arg2 = 0 ;
65854
65855   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65856   arg2 = (Dali::Actor *)jarg2;
65857   if (!arg2) {
65858     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
65859     return ;
65860   }
65861   {
65862     try {
65863       (arg1)->OnControlChildRemove(*arg2);
65864     } catch (std::out_of_range& e) {
65865       {
65866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65867       };
65868     } catch (std::exception& e) {
65869       {
65870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65871       };
65872     } catch (Dali::DaliException e) {
65873       {
65874         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65875       };
65876     } catch (...) {
65877       {
65878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65879       };
65880     }
65881   }
65882
65883 }
65884
65885
65886 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
65887   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65888   Dali::Actor *arg2 = 0 ;
65889
65890   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65891   arg2 = (Dali::Actor *)jarg2;
65892   if (!arg2) {
65893     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
65894     return ;
65895   }
65896   {
65897     try {
65898       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildRemove(*arg2);
65899     } catch (std::out_of_range& e) {
65900       {
65901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65902       };
65903     } catch (std::exception& e) {
65904       {
65905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65906       };
65907     } catch (Dali::DaliException e) {
65908       {
65909         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65910       };
65911     } catch (...) {
65912       {
65913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65914       };
65915     }
65916   }
65917
65918 }
65919
65920
65921 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChange(void * jarg1, void * jarg2, int jarg3) {
65922   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65923   Dali::Toolkit::StyleManager arg2 ;
65924   Dali::StyleChange::Type arg3 ;
65925   Dali::Toolkit::StyleManager *argp2 ;
65926
65927   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65928   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
65929   if (!argp2) {
65930     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
65931     return ;
65932   }
65933   arg2 = *argp2;
65934   arg3 = (Dali::StyleChange::Type)jarg3;
65935   {
65936     try {
65937       (arg1)->OnStyleChange(arg2,arg3);
65938     } catch (std::out_of_range& e) {
65939       {
65940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65941       };
65942     } catch (std::exception& e) {
65943       {
65944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65945       };
65946     } catch (Dali::DaliException e) {
65947       {
65948         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65949       };
65950     } catch (...) {
65951       {
65952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65953       };
65954     }
65955   }
65956
65957 }
65958
65959
65960 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChangeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
65961   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65962   Dali::Toolkit::StyleManager arg2 ;
65963   Dali::StyleChange::Type arg3 ;
65964   Dali::Toolkit::StyleManager *argp2 ;
65965
65966   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65967   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
65968   if (!argp2) {
65969     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
65970     return ;
65971   }
65972   arg2 = *argp2;
65973   arg3 = (Dali::StyleChange::Type)jarg3;
65974   {
65975     try {
65976       (arg1)->Dali::Toolkit::Internal::Control::OnStyleChange(arg2,arg3);
65977     } catch (std::out_of_range& e) {
65978       {
65979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65980       };
65981     } catch (std::exception& e) {
65982       {
65983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65984       };
65985     } catch (Dali::DaliException e) {
65986       {
65987         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65988       };
65989     } catch (...) {
65990       {
65991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65992       };
65993     }
65994   }
65995
65996 }
65997
65998
65999 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivated(void * jarg1) {
66000   unsigned int jresult ;
66001   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66002   bool result;
66003
66004   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66005   {
66006     try {
66007       result = (bool)(arg1)->OnAccessibilityActivated();
66008     } catch (std::out_of_range& e) {
66009       {
66010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66011       };
66012     } catch (std::exception& e) {
66013       {
66014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66015       };
66016     } catch (Dali::DaliException e) {
66017       {
66018         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66019       };
66020     } catch (...) {
66021       {
66022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66023       };
66024     }
66025   }
66026
66027   jresult = result;
66028   return jresult;
66029 }
66030
66031
66032 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivatedSwigExplicitViewImpl(void * jarg1) {
66033   unsigned int jresult ;
66034   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66035   bool result;
66036
66037   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66038   {
66039     try {
66040       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
66041     } catch (std::out_of_range& e) {
66042       {
66043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66044       };
66045     } catch (std::exception& e) {
66046       {
66047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66048       };
66049     } catch (Dali::DaliException e) {
66050       {
66051         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66052       };
66053     } catch (...) {
66054       {
66055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66056       };
66057     }
66058   }
66059
66060   jresult = result;
66061   return jresult;
66062 }
66063
66064
66065 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPan(void * jarg1, void * jarg2) {
66066   unsigned int jresult ;
66067   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66068   Dali::PanGesture arg2 ;
66069   Dali::PanGesture *argp2 ;
66070   bool result;
66071
66072   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66073   argp2 = (Dali::PanGesture *)jarg2;
66074   if (!argp2) {
66075     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
66076     return 0;
66077   }
66078   arg2 = *argp2;
66079   {
66080     try {
66081       result = (bool)(arg1)->OnAccessibilityPan(arg2);
66082     } catch (std::out_of_range& e) {
66083       {
66084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66085       };
66086     } catch (std::exception& e) {
66087       {
66088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66089       };
66090     } catch (Dali::DaliException e) {
66091       {
66092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66093       };
66094     } catch (...) {
66095       {
66096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66097       };
66098     }
66099   }
66100
66101   jresult = result;
66102   return jresult;
66103 }
66104
66105
66106 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66107   unsigned int jresult ;
66108   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66109   Dali::PanGesture arg2 ;
66110   Dali::PanGesture *argp2 ;
66111   bool result;
66112
66113   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66114   argp2 = (Dali::PanGesture *)jarg2;
66115   if (!argp2) {
66116     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
66117     return 0;
66118   }
66119   arg2 = *argp2;
66120   {
66121     try {
66122       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityPan(arg2);
66123     } catch (std::out_of_range& e) {
66124       {
66125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66126       };
66127     } catch (std::exception& e) {
66128       {
66129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66130       };
66131     } catch (Dali::DaliException e) {
66132       {
66133         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66134       };
66135     } catch (...) {
66136       {
66137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66138       };
66139     }
66140   }
66141
66142   jresult = result;
66143   return jresult;
66144 }
66145
66146
66147 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouch(void * jarg1, void * jarg2) {
66148   unsigned int jresult ;
66149   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66150   Dali::TouchEvent *arg2 = 0 ;
66151   bool result;
66152
66153   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66154   arg2 = (Dali::TouchEvent *)jarg2;
66155   if (!arg2) {
66156     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
66157     return 0;
66158   }
66159   {
66160     try {
66161       result = (bool)(arg1)->OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
66162     } catch (std::out_of_range& e) {
66163       {
66164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66165       };
66166     } catch (std::exception& e) {
66167       {
66168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66169       };
66170     } catch (Dali::DaliException e) {
66171       {
66172         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66173       };
66174     } catch (...) {
66175       {
66176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66177       };
66178     }
66179   }
66180
66181   jresult = result;
66182   return jresult;
66183 }
66184
66185
66186 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66187   unsigned int jresult ;
66188   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66189   Dali::TouchEvent *arg2 = 0 ;
66190   bool result;
66191
66192   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66193   arg2 = (Dali::TouchEvent *)jarg2;
66194   if (!arg2) {
66195     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
66196     return 0;
66197   }
66198   {
66199     try {
66200       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
66201     } catch (std::out_of_range& e) {
66202       {
66203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66204       };
66205     } catch (std::exception& e) {
66206       {
66207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66208       };
66209     } catch (Dali::DaliException e) {
66210       {
66211         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66212       };
66213     } catch (...) {
66214       {
66215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66216       };
66217     }
66218   }
66219
66220   jresult = result;
66221   return jresult;
66222 }
66223
66224
66225 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChange(void * jarg1, unsigned int jarg2) {
66226   unsigned int jresult ;
66227   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66228   bool arg2 ;
66229   bool result;
66230
66231   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66232   arg2 = jarg2 ? true : false;
66233   {
66234     try {
66235       result = (bool)(arg1)->OnAccessibilityValueChange(arg2);
66236     } catch (std::out_of_range& e) {
66237       {
66238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66239       };
66240     } catch (std::exception& e) {
66241       {
66242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66243       };
66244     } catch (Dali::DaliException e) {
66245       {
66246         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66247       };
66248     } catch (...) {
66249       {
66250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66251       };
66252     }
66253   }
66254
66255   jresult = result;
66256   return jresult;
66257 }
66258
66259
66260 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChangeSwigExplicitViewImpl(void * jarg1, unsigned int jarg2) {
66261   unsigned int jresult ;
66262   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66263   bool arg2 ;
66264   bool result;
66265
66266   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66267   arg2 = jarg2 ? true : false;
66268   {
66269     try {
66270       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(arg2);
66271     } catch (std::out_of_range& e) {
66272       {
66273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66274       };
66275     } catch (std::exception& e) {
66276       {
66277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66278       };
66279     } catch (Dali::DaliException e) {
66280       {
66281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66282       };
66283     } catch (...) {
66284       {
66285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66286       };
66287     }
66288   }
66289
66290   jresult = result;
66291   return jresult;
66292 }
66293
66294
66295 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoom(void * jarg1) {
66296   unsigned int jresult ;
66297   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66298   bool result;
66299
66300   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66301   {
66302     try {
66303       result = (bool)(arg1)->OnAccessibilityZoom();
66304     } catch (std::out_of_range& e) {
66305       {
66306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66307       };
66308     } catch (std::exception& e) {
66309       {
66310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66311       };
66312     } catch (Dali::DaliException e) {
66313       {
66314         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66315       };
66316     } catch (...) {
66317       {
66318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66319       };
66320     }
66321   }
66322
66323   jresult = result;
66324   return jresult;
66325 }
66326
66327
66328 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoomSwigExplicitViewImpl(void * jarg1) {
66329   unsigned int jresult ;
66330   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66331   bool result;
66332
66333   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66334   {
66335     try {
66336       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
66337     } catch (std::out_of_range& e) {
66338       {
66339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66340       };
66341     } catch (std::exception& e) {
66342       {
66343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66344       };
66345     } catch (Dali::DaliException e) {
66346       {
66347         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66348       };
66349     } catch (...) {
66350       {
66351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66352       };
66353     }
66354   }
66355
66356   jresult = result;
66357   return jresult;
66358 }
66359
66360
66361 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGained(void * jarg1) {
66362   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66363
66364   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66365   {
66366     try {
66367       (arg1)->OnKeyInputFocusGained();
66368     } catch (std::out_of_range& e) {
66369       {
66370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66371       };
66372     } catch (std::exception& e) {
66373       {
66374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66375       };
66376     } catch (Dali::DaliException e) {
66377       {
66378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66379       };
66380     } catch (...) {
66381       {
66382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66383       };
66384     }
66385   }
66386
66387 }
66388
66389
66390 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGainedSwigExplicitViewImpl(void * jarg1) {
66391   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66392
66393   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66394   {
66395     try {
66396       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
66397     } catch (std::out_of_range& e) {
66398       {
66399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66400       };
66401     } catch (std::exception& e) {
66402       {
66403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66404       };
66405     } catch (Dali::DaliException e) {
66406       {
66407         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66408       };
66409     } catch (...) {
66410       {
66411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66412       };
66413     }
66414   }
66415
66416 }
66417
66418
66419 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLost(void * jarg1) {
66420   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66421
66422   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66423   {
66424     try {
66425       (arg1)->OnKeyInputFocusLost();
66426     } catch (std::out_of_range& e) {
66427       {
66428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66429       };
66430     } catch (std::exception& e) {
66431       {
66432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66433       };
66434     } catch (Dali::DaliException e) {
66435       {
66436         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66437       };
66438     } catch (...) {
66439       {
66440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66441       };
66442     }
66443   }
66444
66445 }
66446
66447
66448 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLostSwigExplicitViewImpl(void * jarg1) {
66449   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66450
66451   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66452   {
66453     try {
66454       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
66455     } catch (std::out_of_range& e) {
66456       {
66457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66458       };
66459     } catch (std::exception& e) {
66460       {
66461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66462       };
66463     } catch (Dali::DaliException e) {
66464       {
66465         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66466       };
66467     } catch (...) {
66468       {
66469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66470       };
66471     }
66472   }
66473
66474 }
66475
66476
66477 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActor(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
66478   void * jresult ;
66479   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66480   Dali::Actor arg2 ;
66481   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
66482   bool arg4 ;
66483   Dali::Actor *argp2 ;
66484   Dali::Actor result;
66485
66486   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66487   argp2 = (Dali::Actor *)jarg2;
66488   if (!argp2) {
66489     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66490     return 0;
66491   }
66492   arg2 = *argp2;
66493   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
66494   arg4 = jarg4 ? true : false;
66495   {
66496     try {
66497       result = (arg1)->GetNextKeyboardFocusableActor(arg2,arg3,arg4);
66498     } catch (std::out_of_range& e) {
66499       {
66500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66501       };
66502     } catch (std::exception& e) {
66503       {
66504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66505       };
66506     } catch (Dali::DaliException e) {
66507       {
66508         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66509       };
66510     } catch (...) {
66511       {
66512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66513       };
66514     }
66515   }
66516
66517   jresult = new Dali::Actor((const Dali::Actor &)result);
66518   return jresult;
66519 }
66520
66521
66522 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActorSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
66523   void * jresult ;
66524   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66525   Dali::Actor arg2 ;
66526   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
66527   bool arg4 ;
66528   Dali::Actor *argp2 ;
66529   Dali::Actor result;
66530
66531   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66532   argp2 = (Dali::Actor *)jarg2;
66533   if (!argp2) {
66534     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66535     return 0;
66536   }
66537   arg2 = *argp2;
66538   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
66539   arg4 = jarg4 ? true : false;
66540   {
66541     try {
66542       result = (arg1)->Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(arg2,arg3,arg4);
66543     } catch (std::out_of_range& e) {
66544       {
66545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66546       };
66547     } catch (std::exception& e) {
66548       {
66549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66550       };
66551     } catch (Dali::DaliException e) {
66552       {
66553         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66554       };
66555     } catch (...) {
66556       {
66557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66558       };
66559     }
66560   }
66561
66562   jresult = new Dali::Actor((const Dali::Actor &)result);
66563   return jresult;
66564 }
66565
66566
66567 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommitted(void * jarg1, void * jarg2) {
66568   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66569   Dali::Actor arg2 ;
66570   Dali::Actor *argp2 ;
66571
66572   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66573   argp2 = (Dali::Actor *)jarg2;
66574   if (!argp2) {
66575     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66576     return ;
66577   }
66578   arg2 = *argp2;
66579   {
66580     try {
66581       (arg1)->OnKeyboardFocusChangeCommitted(arg2);
66582     } catch (std::out_of_range& e) {
66583       {
66584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66585       };
66586     } catch (std::exception& e) {
66587       {
66588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66589       };
66590     } catch (Dali::DaliException e) {
66591       {
66592         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66593       };
66594     } catch (...) {
66595       {
66596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66597       };
66598     }
66599   }
66600
66601 }
66602
66603
66604 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommittedSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66605   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66606   Dali::Actor arg2 ;
66607   Dali::Actor *argp2 ;
66608
66609   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66610   argp2 = (Dali::Actor *)jarg2;
66611   if (!argp2) {
66612     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66613     return ;
66614   }
66615   arg2 = *argp2;
66616   {
66617     try {
66618       (arg1)->Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(arg2);
66619     } catch (std::out_of_range& e) {
66620       {
66621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66622       };
66623     } catch (std::exception& e) {
66624       {
66625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66626       };
66627     } catch (Dali::DaliException e) {
66628       {
66629         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66630       };
66631     } catch (...) {
66632       {
66633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66634       };
66635     }
66636   }
66637
66638 }
66639
66640
66641 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnter(void * jarg1) {
66642   unsigned int jresult ;
66643   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66644   bool result;
66645
66646   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66647   {
66648     try {
66649       result = (bool)(arg1)->OnKeyboardEnter();
66650     } catch (std::out_of_range& e) {
66651       {
66652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66653       };
66654     } catch (std::exception& e) {
66655       {
66656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66657       };
66658     } catch (Dali::DaliException e) {
66659       {
66660         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66661       };
66662     } catch (...) {
66663       {
66664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66665       };
66666     }
66667   }
66668
66669   jresult = result;
66670   return jresult;
66671 }
66672
66673
66674 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnterSwigExplicitViewImpl(void * jarg1) {
66675   unsigned int jresult ;
66676   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66677   bool result;
66678
66679   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66680   {
66681     try {
66682       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnKeyboardEnter();
66683     } catch (std::out_of_range& e) {
66684       {
66685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66686       };
66687     } catch (std::exception& e) {
66688       {
66689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66690       };
66691     } catch (Dali::DaliException e) {
66692       {
66693         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66694       };
66695     } catch (...) {
66696       {
66697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66698       };
66699     }
66700   }
66701
66702   jresult = result;
66703   return jresult;
66704 }
66705
66706
66707 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinch(void * jarg1, void * jarg2) {
66708   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66709   Dali::PinchGesture *arg2 = 0 ;
66710
66711   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66712   arg2 = (Dali::PinchGesture *)jarg2;
66713   if (!arg2) {
66714     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
66715     return ;
66716   }
66717   {
66718     try {
66719       (arg1)->OnPinch((Dali::PinchGesture const &)*arg2);
66720     } catch (std::out_of_range& e) {
66721       {
66722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66723       };
66724     } catch (std::exception& e) {
66725       {
66726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66727       };
66728     } catch (Dali::DaliException e) {
66729       {
66730         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66731       };
66732     } catch (...) {
66733       {
66734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66735       };
66736     }
66737   }
66738
66739 }
66740
66741
66742 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66743   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66744   Dali::PinchGesture *arg2 = 0 ;
66745
66746   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66747   arg2 = (Dali::PinchGesture *)jarg2;
66748   if (!arg2) {
66749     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
66750     return ;
66751   }
66752   {
66753     try {
66754       (arg1)->Dali::Toolkit::Internal::Control::OnPinch((Dali::PinchGesture const &)*arg2);
66755     } catch (std::out_of_range& e) {
66756       {
66757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66758       };
66759     } catch (std::exception& e) {
66760       {
66761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66762       };
66763     } catch (Dali::DaliException e) {
66764       {
66765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66766       };
66767     } catch (...) {
66768       {
66769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66770       };
66771     }
66772   }
66773
66774 }
66775
66776
66777 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPan(void * jarg1, void * jarg2) {
66778   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66779   Dali::PanGesture *arg2 = 0 ;
66780
66781   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66782   arg2 = (Dali::PanGesture *)jarg2;
66783   if (!arg2) {
66784     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
66785     return ;
66786   }
66787   {
66788     try {
66789       (arg1)->OnPan((Dali::PanGesture const &)*arg2);
66790     } catch (std::out_of_range& e) {
66791       {
66792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66793       };
66794     } catch (std::exception& e) {
66795       {
66796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66797       };
66798     } catch (Dali::DaliException e) {
66799       {
66800         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66801       };
66802     } catch (...) {
66803       {
66804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66805       };
66806     }
66807   }
66808
66809 }
66810
66811
66812 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66813   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66814   Dali::PanGesture *arg2 = 0 ;
66815
66816   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66817   arg2 = (Dali::PanGesture *)jarg2;
66818   if (!arg2) {
66819     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
66820     return ;
66821   }
66822   {
66823     try {
66824       (arg1)->Dali::Toolkit::Internal::Control::OnPan((Dali::PanGesture const &)*arg2);
66825     } catch (std::out_of_range& e) {
66826       {
66827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66828       };
66829     } catch (std::exception& e) {
66830       {
66831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66832       };
66833     } catch (Dali::DaliException e) {
66834       {
66835         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66836       };
66837     } catch (...) {
66838       {
66839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66840       };
66841     }
66842   }
66843
66844 }
66845
66846
66847 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTap(void * jarg1, void * jarg2) {
66848   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66849   Dali::TapGesture *arg2 = 0 ;
66850
66851   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66852   arg2 = (Dali::TapGesture *)jarg2;
66853   if (!arg2) {
66854     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
66855     return ;
66856   }
66857   {
66858     try {
66859       (arg1)->OnTap((Dali::TapGesture const &)*arg2);
66860     } catch (std::out_of_range& e) {
66861       {
66862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66863       };
66864     } catch (std::exception& e) {
66865       {
66866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66867       };
66868     } catch (Dali::DaliException e) {
66869       {
66870         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66871       };
66872     } catch (...) {
66873       {
66874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66875       };
66876     }
66877   }
66878
66879 }
66880
66881
66882 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTapSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66883   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66884   Dali::TapGesture *arg2 = 0 ;
66885
66886   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66887   arg2 = (Dali::TapGesture *)jarg2;
66888   if (!arg2) {
66889     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
66890     return ;
66891   }
66892   {
66893     try {
66894       (arg1)->Dali::Toolkit::Internal::Control::OnTap((Dali::TapGesture const &)*arg2);
66895     } catch (std::out_of_range& e) {
66896       {
66897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66898       };
66899     } catch (std::exception& e) {
66900       {
66901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66902       };
66903     } catch (Dali::DaliException e) {
66904       {
66905         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66906       };
66907     } catch (...) {
66908       {
66909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66910       };
66911     }
66912   }
66913
66914 }
66915
66916
66917 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPress(void * jarg1, void * jarg2) {
66918   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66919   Dali::LongPressGesture *arg2 = 0 ;
66920
66921   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66922   arg2 = (Dali::LongPressGesture *)jarg2;
66923   if (!arg2) {
66924     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
66925     return ;
66926   }
66927   {
66928     try {
66929       (arg1)->OnLongPress((Dali::LongPressGesture const &)*arg2);
66930     } catch (std::out_of_range& e) {
66931       {
66932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66933       };
66934     } catch (std::exception& e) {
66935       {
66936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66937       };
66938     } catch (Dali::DaliException e) {
66939       {
66940         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66941       };
66942     } catch (...) {
66943       {
66944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66945       };
66946     }
66947   }
66948
66949 }
66950
66951
66952 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPressSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66953   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66954   Dali::LongPressGesture *arg2 = 0 ;
66955
66956   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66957   arg2 = (Dali::LongPressGesture *)jarg2;
66958   if (!arg2) {
66959     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
66960     return ;
66961   }
66962   {
66963     try {
66964       (arg1)->Dali::Toolkit::Internal::Control::OnLongPress((Dali::LongPressGesture const &)*arg2);
66965     } catch (std::out_of_range& e) {
66966       {
66967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66968       };
66969     } catch (std::exception& e) {
66970       {
66971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66972       };
66973     } catch (Dali::DaliException e) {
66974       {
66975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66976       };
66977     } catch (...) {
66978       {
66979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66980       };
66981     }
66982   }
66983
66984 }
66985
66986
66987 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
66988   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66989   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
66990   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
66991
66992   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66993   arg2 = (Dali::SlotObserver *)jarg2;
66994   arg3 = (Dali::CallbackBase *)jarg3;
66995   {
66996     try {
66997       (arg1)->SignalConnected(arg2,arg3);
66998     } catch (std::out_of_range& e) {
66999       {
67000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67001       };
67002     } catch (std::exception& e) {
67003       {
67004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67005       };
67006     } catch (Dali::DaliException e) {
67007       {
67008         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67009       };
67010     } catch (...) {
67011       {
67012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67013       };
67014     }
67015   }
67016
67017 }
67018
67019
67020 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
67021   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67022   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
67023   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
67024
67025   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67026   arg2 = (Dali::SlotObserver *)jarg2;
67027   arg3 = (Dali::CallbackBase *)jarg3;
67028   {
67029     try {
67030       (arg1)->Dali::Toolkit::Internal::Control::SignalConnected(arg2,arg3);
67031     } catch (std::out_of_range& e) {
67032       {
67033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67034       };
67035     } catch (std::exception& e) {
67036       {
67037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67038       };
67039     } catch (Dali::DaliException e) {
67040       {
67041         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67042       };
67043     } catch (...) {
67044       {
67045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67046       };
67047     }
67048   }
67049
67050 }
67051
67052
67053 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
67054   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67055   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
67056   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
67057
67058   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67059   arg2 = (Dali::SlotObserver *)jarg2;
67060   arg3 = (Dali::CallbackBase *)jarg3;
67061   {
67062     try {
67063       (arg1)->SignalDisconnected(arg2,arg3);
67064     } catch (std::out_of_range& e) {
67065       {
67066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67067       };
67068     } catch (std::exception& e) {
67069       {
67070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67071       };
67072     } catch (Dali::DaliException e) {
67073       {
67074         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67075       };
67076     } catch (...) {
67077       {
67078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67079       };
67080     }
67081   }
67082
67083 }
67084
67085
67086 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
67087   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67088   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
67089   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
67090
67091   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67092   arg2 = (Dali::SlotObserver *)jarg2;
67093   arg3 = (Dali::CallbackBase *)jarg3;
67094   {
67095     try {
67096       (arg1)->Dali::Toolkit::Internal::Control::SignalDisconnected(arg2,arg3);
67097     } catch (std::out_of_range& e) {
67098       {
67099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67100       };
67101     } catch (std::exception& e) {
67102       {
67103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67104       };
67105     } catch (Dali::DaliException e) {
67106       {
67107         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67108       };
67109     } catch (...) {
67110       {
67111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67112       };
67113     }
67114   }
67115
67116 }
67117
67118
67119 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) {
67120   Dali::Toolkit::Internal::Control *obj = (Dali::Toolkit::Internal::Control *)objarg;
67121   SwigDirector_ViewImpl *director = dynamic_cast<SwigDirector_ViewImpl *>(obj);
67122   if (director) {
67123     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);
67124   }
67125 }
67126
67127
67128 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation__SWIG_0(void * jarg1) {
67129   void * jresult ;
67130   Dali::Toolkit::Control *arg1 = 0 ;
67131   Dali::Toolkit::Internal::Control *result = 0 ;
67132
67133   arg1 = (Dali::Toolkit::Control *)jarg1;
67134   if (!arg1) {
67135     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
67136     return 0;
67137   }
67138   {
67139     try {
67140       result = (Dali::Toolkit::Internal::Control *) &Dali::Toolkit::Internal::GetImplementation(*arg1);
67141     } catch (std::out_of_range& e) {
67142       {
67143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67144       };
67145     } catch (std::exception& e) {
67146       {
67147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67148       };
67149     } catch (Dali::DaliException e) {
67150       {
67151         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67152       };
67153     } catch (...) {
67154       {
67155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67156       };
67157     }
67158   }
67159
67160   jresult = (void *)result;
67161   return jresult;
67162 }
67163
67164
67165 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_STYLE_NAME_get() {
67166   int jresult ;
67167   int result;
67168
67169   result = (int)Dali::Toolkit::Control::Property::STYLE_NAME;
67170   jresult = (int)result;
67171   return jresult;
67172 }
67173
67174
67175 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_COLOR_get() {
67176   int jresult ;
67177   int result;
67178
67179   result = (int)Dali::Toolkit::Control::Property::BACKGROUND_COLOR;
67180   jresult = (int)result;
67181   return jresult;
67182 }
67183
67184
67185 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_IMAGE_get() {
67186   int jresult ;
67187   int result;
67188
67189   result = (int)Dali::Toolkit::Control::Property::BACKGROUND_IMAGE;
67190   jresult = (int)result;
67191   return jresult;
67192 }
67193
67194
67195 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_KEY_INPUT_FOCUS_get() {
67196   int jresult ;
67197   int result;
67198
67199   result = (int)Dali::Toolkit::Control::Property::KEY_INPUT_FOCUS;
67200   jresult = (int)result;
67201   return jresult;
67202 }
67203
67204
67205 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_get() {
67206   int jresult ;
67207   int result;
67208
67209   result = (int)Dali::Toolkit::Control::Property::BACKGROUND;
67210   jresult = (int)result;
67211   return jresult;
67212 }
67213
67214 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_MARGIN_get() {
67215   int jresult ;
67216   int result;
67217
67218   result = (int)Dali::Toolkit::Control::Property::MARGIN;
67219   jresult = (int)result;
67220   return jresult;
67221 }
67222
67223
67224 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_PADDING_get() {
67225   int jresult ;
67226   int result;
67227
67228   result = (int)Dali::Toolkit::Control::Property::PADDING;
67229   jresult = (int)result;
67230   return jresult;
67231 }
67232
67233 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_Property() {
67234   void * jresult ;
67235   Dali::Toolkit::Control::Property *result = 0 ;
67236
67237   {
67238     try {
67239       result = (Dali::Toolkit::Control::Property *)new Dali::Toolkit::Control::Property();
67240     } catch (std::out_of_range& e) {
67241       {
67242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67243       };
67244     } catch (std::exception& e) {
67245       {
67246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67247       };
67248     } catch (Dali::DaliException e) {
67249       {
67250         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67251       };
67252     } catch (...) {
67253       {
67254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67255       };
67256     }
67257   }
67258
67259   jresult = (void *)result;
67260   return jresult;
67261 }
67262
67263
67264 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_Property(void * jarg1) {
67265   Dali::Toolkit::Control::Property *arg1 = (Dali::Toolkit::Control::Property *) 0 ;
67266
67267   arg1 = (Dali::Toolkit::Control::Property *)jarg1;
67268   {
67269     try {
67270       delete arg1;
67271     } catch (std::out_of_range& e) {
67272       {
67273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67274       };
67275     } catch (std::exception& e) {
67276       {
67277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67278       };
67279     } catch (Dali::DaliException e) {
67280       {
67281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67282       };
67283     } catch (...) {
67284       {
67285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67286       };
67287     }
67288   }
67289
67290 }
67291
67292
67293 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_KeyboardFocus() {
67294   void * jresult ;
67295   Dali::Toolkit::Control::KeyboardFocus *result = 0 ;
67296
67297   {
67298     try {
67299       result = (Dali::Toolkit::Control::KeyboardFocus *)new Dali::Toolkit::Control::KeyboardFocus();
67300     } catch (std::out_of_range& e) {
67301       {
67302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67303       };
67304     } catch (std::exception& e) {
67305       {
67306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67307       };
67308     } catch (Dali::DaliException e) {
67309       {
67310         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67311       };
67312     } catch (...) {
67313       {
67314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67315       };
67316     }
67317   }
67318
67319   jresult = (void *)result;
67320   return jresult;
67321 }
67322
67323
67324 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_KeyboardFocus(void * jarg1) {
67325   Dali::Toolkit::Control::KeyboardFocus *arg1 = (Dali::Toolkit::Control::KeyboardFocus *) 0 ;
67326
67327   arg1 = (Dali::Toolkit::Control::KeyboardFocus *)jarg1;
67328   {
67329     try {
67330       delete arg1;
67331     } catch (std::out_of_range& e) {
67332       {
67333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67334       };
67335     } catch (std::exception& e) {
67336       {
67337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67338       };
67339     } catch (Dali::DaliException e) {
67340       {
67341         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67342       };
67343     } catch (...) {
67344       {
67345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67346       };
67347     }
67348   }
67349
67350 }
67351
67352
67353 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_New() {
67354   void * jresult ;
67355   Dali::Toolkit::Control result;
67356
67357   {
67358     try {
67359       result = Dali::Toolkit::Control::New();
67360     } catch (std::out_of_range& e) {
67361       {
67362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67363       };
67364     } catch (std::exception& e) {
67365       {
67366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67367       };
67368     } catch (Dali::DaliException e) {
67369       {
67370         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67371       };
67372     } catch (...) {
67373       {
67374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67375       };
67376     }
67377   }
67378
67379   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
67380   return jresult;
67381 }
67382
67383
67384 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_0() {
67385   void * jresult ;
67386   Dali::Toolkit::Control *result = 0 ;
67387
67388   {
67389     try {
67390       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control();
67391     } catch (std::out_of_range& e) {
67392       {
67393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67394       };
67395     } catch (std::exception& e) {
67396       {
67397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67398       };
67399     } catch (Dali::DaliException e) {
67400       {
67401         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67402       };
67403     } catch (...) {
67404       {
67405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67406       };
67407     }
67408   }
67409
67410   jresult = (void *)result;
67411   return jresult;
67412 }
67413
67414
67415 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_1(void * jarg1) {
67416   void * jresult ;
67417   Dali::Toolkit::Control *arg1 = 0 ;
67418   Dali::Toolkit::Control *result = 0 ;
67419
67420   arg1 = (Dali::Toolkit::Control *)jarg1;
67421   if (!arg1) {
67422     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
67423     return 0;
67424   }
67425   {
67426     try {
67427       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control((Dali::Toolkit::Control const &)*arg1);
67428     } catch (std::out_of_range& e) {
67429       {
67430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67431       };
67432     } catch (std::exception& e) {
67433       {
67434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67435       };
67436     } catch (Dali::DaliException e) {
67437       {
67438         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67439       };
67440     } catch (...) {
67441       {
67442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67443       };
67444     }
67445   }
67446
67447   jresult = (void *)result;
67448   return jresult;
67449 }
67450
67451
67452 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View(void * jarg1) {
67453   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67454
67455   arg1 = (Dali::Toolkit::Control *)jarg1;
67456   {
67457     try {
67458       delete arg1;
67459     } catch (std::out_of_range& e) {
67460       {
67461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67462       };
67463     } catch (std::exception& e) {
67464       {
67465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67466       };
67467     } catch (Dali::DaliException e) {
67468       {
67469         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67470       };
67471     } catch (...) {
67472       {
67473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67474       };
67475     }
67476   }
67477
67478 }
67479
67480
67481 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_Assign(void * jarg1, void * jarg2) {
67482   void * jresult ;
67483   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67484   Dali::Toolkit::Control *arg2 = 0 ;
67485   Dali::Toolkit::Control *result = 0 ;
67486
67487   arg1 = (Dali::Toolkit::Control *)jarg1;
67488   arg2 = (Dali::Toolkit::Control *)jarg2;
67489   if (!arg2) {
67490     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
67491     return 0;
67492   }
67493   {
67494     try {
67495       result = (Dali::Toolkit::Control *) &(arg1)->operator =((Dali::Toolkit::Control const &)*arg2);
67496     } catch (std::out_of_range& e) {
67497       {
67498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67499       };
67500     } catch (std::exception& e) {
67501       {
67502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67503       };
67504     } catch (Dali::DaliException e) {
67505       {
67506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67507       };
67508     } catch (...) {
67509       {
67510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67511       };
67512     }
67513   }
67514
67515   jresult = (void *)result;
67516   return jresult;
67517 }
67518
67519
67520 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_DownCast(void * jarg1) {
67521   void * jresult ;
67522   Dali::BaseHandle arg1 ;
67523   Dali::BaseHandle *argp1 ;
67524   Dali::Toolkit::Control result;
67525
67526   argp1 = (Dali::BaseHandle *)jarg1;
67527   if (!argp1) {
67528     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
67529     return 0;
67530   }
67531   arg1 = *argp1;
67532   {
67533     try {
67534       result = Dali::Toolkit::Control::DownCast(arg1);
67535     } catch (std::out_of_range& e) {
67536       {
67537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67538       };
67539     } catch (std::exception& e) {
67540       {
67541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67542       };
67543     } catch (Dali::DaliException e) {
67544       {
67545         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67546       };
67547     } catch (...) {
67548       {
67549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67550       };
67551     }
67552   }
67553
67554   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
67555   return jresult;
67556 }
67557
67558
67559 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetKeyInputFocus(void * jarg1) {
67560   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67561
67562   arg1 = (Dali::Toolkit::Control *)jarg1;
67563   {
67564     try {
67565       (arg1)->SetKeyInputFocus();
67566     } catch (std::out_of_range& e) {
67567       {
67568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67569       };
67570     } catch (std::exception& e) {
67571       {
67572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67573       };
67574     } catch (Dali::DaliException e) {
67575       {
67576         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67577       };
67578     } catch (...) {
67579       {
67580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67581       };
67582     }
67583   }
67584
67585 }
67586
67587
67588 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_View_HasKeyInputFocus(void * jarg1) {
67589   unsigned int jresult ;
67590   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67591   bool result;
67592
67593   arg1 = (Dali::Toolkit::Control *)jarg1;
67594   {
67595     try {
67596       result = (bool)(arg1)->HasKeyInputFocus();
67597     } catch (std::out_of_range& e) {
67598       {
67599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67600       };
67601     } catch (std::exception& e) {
67602       {
67603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67604       };
67605     } catch (Dali::DaliException e) {
67606       {
67607         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67608       };
67609     } catch (...) {
67610       {
67611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67612       };
67613     }
67614   }
67615
67616   jresult = result;
67617   return jresult;
67618 }
67619
67620
67621 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearKeyInputFocus(void * jarg1) {
67622   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67623
67624   arg1 = (Dali::Toolkit::Control *)jarg1;
67625   {
67626     try {
67627       (arg1)->ClearKeyInputFocus();
67628     } catch (std::out_of_range& e) {
67629       {
67630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67631       };
67632     } catch (std::exception& e) {
67633       {
67634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67635       };
67636     } catch (Dali::DaliException e) {
67637       {
67638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67639       };
67640     } catch (...) {
67641       {
67642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67643       };
67644     }
67645   }
67646
67647 }
67648
67649
67650 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPinchGestureDetector(void * jarg1) {
67651   void * jresult ;
67652   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67653   Dali::PinchGestureDetector result;
67654
67655   arg1 = (Dali::Toolkit::Control *)jarg1;
67656   {
67657     try {
67658       result = ((Dali::Toolkit::Control const *)arg1)->GetPinchGestureDetector();
67659     } catch (std::out_of_range& e) {
67660       {
67661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67662       };
67663     } catch (std::exception& e) {
67664       {
67665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67666       };
67667     } catch (Dali::DaliException e) {
67668       {
67669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67670       };
67671     } catch (...) {
67672       {
67673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67674       };
67675     }
67676   }
67677
67678   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
67679   return jresult;
67680 }
67681
67682
67683 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPanGestureDetector(void * jarg1) {
67684   void * jresult ;
67685   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67686   Dali::PanGestureDetector result;
67687
67688   arg1 = (Dali::Toolkit::Control *)jarg1;
67689   {
67690     try {
67691       result = ((Dali::Toolkit::Control const *)arg1)->GetPanGestureDetector();
67692     } catch (std::out_of_range& e) {
67693       {
67694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67695       };
67696     } catch (std::exception& e) {
67697       {
67698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67699       };
67700     } catch (Dali::DaliException e) {
67701       {
67702         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67703       };
67704     } catch (...) {
67705       {
67706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67707       };
67708     }
67709   }
67710
67711   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
67712   return jresult;
67713 }
67714
67715
67716 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetTapGestureDetector(void * jarg1) {
67717   void * jresult ;
67718   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67719   Dali::TapGestureDetector result;
67720
67721   arg1 = (Dali::Toolkit::Control *)jarg1;
67722   {
67723     try {
67724       result = ((Dali::Toolkit::Control const *)arg1)->GetTapGestureDetector();
67725     } catch (std::out_of_range& e) {
67726       {
67727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67728       };
67729     } catch (std::exception& e) {
67730       {
67731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67732       };
67733     } catch (Dali::DaliException e) {
67734       {
67735         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67736       };
67737     } catch (...) {
67738       {
67739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67740       };
67741     }
67742   }
67743
67744   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
67745   return jresult;
67746 }
67747
67748
67749 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetLongPressGestureDetector(void * jarg1) {
67750   void * jresult ;
67751   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67752   Dali::LongPressGestureDetector result;
67753
67754   arg1 = (Dali::Toolkit::Control *)jarg1;
67755   {
67756     try {
67757       result = ((Dali::Toolkit::Control const *)arg1)->GetLongPressGestureDetector();
67758     } catch (std::out_of_range& e) {
67759       {
67760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67761       };
67762     } catch (std::exception& e) {
67763       {
67764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67765       };
67766     } catch (Dali::DaliException e) {
67767       {
67768         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67769       };
67770     } catch (...) {
67771       {
67772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67773       };
67774     }
67775   }
67776
67777   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
67778   return jresult;
67779 }
67780
67781
67782 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetStyleName(void * jarg1, char * jarg2) {
67783   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67784   std::string *arg2 = 0 ;
67785
67786   arg1 = (Dali::Toolkit::Control *)jarg1;
67787   if (!jarg2) {
67788     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
67789     return ;
67790   }
67791   std::string arg2_str(jarg2);
67792   arg2 = &arg2_str;
67793   {
67794     try {
67795       (arg1)->SetStyleName((std::string const &)*arg2);
67796     } catch (std::out_of_range& e) {
67797       {
67798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67799       };
67800     } catch (std::exception& e) {
67801       {
67802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67803       };
67804     } catch (Dali::DaliException e) {
67805       {
67806         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67807       };
67808     } catch (...) {
67809       {
67810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67811       };
67812     }
67813   }
67814
67815
67816   //argout typemap for const std::string&
67817
67818 }
67819
67820
67821 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_View_GetStyleName(void * jarg1) {
67822   char * jresult ;
67823   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67824   std::string *result = 0 ;
67825
67826   arg1 = (Dali::Toolkit::Control *)jarg1;
67827   {
67828     try {
67829       result = (std::string *) &((Dali::Toolkit::Control const *)arg1)->GetStyleName();
67830     } catch (std::out_of_range& e) {
67831       {
67832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67833       };
67834     } catch (std::exception& e) {
67835       {
67836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67837       };
67838     } catch (Dali::DaliException e) {
67839       {
67840         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67841       };
67842     } catch (...) {
67843       {
67844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67845       };
67846     }
67847   }
67848
67849   jresult = SWIG_csharp_string_callback(result->c_str());
67850   return jresult;
67851 }
67852
67853
67854 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundColor(void * jarg1, void * jarg2) {
67855   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67856   Dali::Vector4 *arg2 = 0 ;
67857
67858   arg1 = (Dali::Toolkit::Control *)jarg1;
67859   arg2 = (Dali::Vector4 *)jarg2;
67860   if (!arg2) {
67861     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
67862     return ;
67863   }
67864   {
67865     try {
67866       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
67867     } catch (std::out_of_range& e) {
67868       {
67869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67870       };
67871     } catch (std::exception& e) {
67872       {
67873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67874       };
67875     } catch (Dali::DaliException e) {
67876       {
67877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67878       };
67879     } catch (...) {
67880       {
67881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67882       };
67883     }
67884   }
67885
67886 }
67887
67888
67889 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetBackgroundColor(void * jarg1) {
67890   void * jresult ;
67891   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67892   Dali::Vector4 result;
67893
67894   arg1 = (Dali::Toolkit::Control *)jarg1;
67895   {
67896     try {
67897       result = ((Dali::Toolkit::Control const *)arg1)->GetBackgroundColor();
67898     } catch (std::out_of_range& e) {
67899       {
67900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67901       };
67902     } catch (std::exception& e) {
67903       {
67904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67905       };
67906     } catch (Dali::DaliException e) {
67907       {
67908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67909       };
67910     } catch (...) {
67911       {
67912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67913       };
67914     }
67915   }
67916
67917   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
67918   return jresult;
67919 }
67920
67921
67922 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundImage(void * jarg1, void * jarg2) {
67923   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67924   Dali::Image arg2 ;
67925   Dali::Image *argp2 ;
67926
67927   arg1 = (Dali::Toolkit::Control *)jarg1;
67928   argp2 = (Dali::Image *)jarg2;
67929   if (!argp2) {
67930     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
67931     return ;
67932   }
67933   arg2 = *argp2;
67934   {
67935     try {
67936       (arg1)->SetBackgroundImage(arg2);
67937     } catch (std::out_of_range& e) {
67938       {
67939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67940       };
67941     } catch (std::exception& e) {
67942       {
67943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67944       };
67945     } catch (Dali::DaliException e) {
67946       {
67947         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67948       };
67949     } catch (...) {
67950       {
67951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67952       };
67953     }
67954   }
67955
67956 }
67957
67958
67959 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearBackground(void * jarg1) {
67960   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67961
67962   arg1 = (Dali::Toolkit::Control *)jarg1;
67963   {
67964     try {
67965       (arg1)->ClearBackground();
67966     } catch (std::out_of_range& e) {
67967       {
67968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67969       };
67970     } catch (std::exception& e) {
67971       {
67972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67973       };
67974     } catch (Dali::DaliException e) {
67975       {
67976         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67977       };
67978     } catch (...) {
67979       {
67980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67981       };
67982     }
67983   }
67984
67985 }
67986
67987
67988 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyEventSignal(void * jarg1) {
67989   void * jresult ;
67990   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67991   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
67992
67993   arg1 = (Dali::Toolkit::Control *)jarg1;
67994   {
67995     try {
67996       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
67997     } catch (std::out_of_range& e) {
67998       {
67999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68000       };
68001     } catch (std::exception& e) {
68002       {
68003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68004       };
68005     } catch (Dali::DaliException e) {
68006       {
68007         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68008       };
68009     } catch (...) {
68010       {
68011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68012       };
68013     }
68014   }
68015
68016   jresult = (void *)result;
68017   return jresult;
68018 }
68019
68020
68021 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusGainedSignal(void * jarg1) {
68022   void * jresult ;
68023   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68024   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
68025
68026   arg1 = (Dali::Toolkit::Control *)jarg1;
68027   {
68028     try {
68029       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
68030     } catch (std::out_of_range& e) {
68031       {
68032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68033       };
68034     } catch (std::exception& e) {
68035       {
68036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68037       };
68038     } catch (Dali::DaliException e) {
68039       {
68040         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68041       };
68042     } catch (...) {
68043       {
68044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68045       };
68046     }
68047   }
68048
68049   jresult = (void *)result;
68050   return jresult;
68051 }
68052
68053
68054 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusLostSignal(void * jarg1) {
68055   void * jresult ;
68056   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68057   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
68058
68059   arg1 = (Dali::Toolkit::Control *)jarg1;
68060   {
68061     try {
68062       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
68063     } catch (std::out_of_range& e) {
68064       {
68065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68066       };
68067     } catch (std::exception& e) {
68068       {
68069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68070       };
68071     } catch (Dali::DaliException e) {
68072       {
68073         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68074       };
68075     } catch (...) {
68076       {
68077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68078       };
68079     }
68080   }
68081
68082   jresult = (void *)result;
68083   return jresult;
68084 }
68085
68086
68087 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_2(void * jarg1) {
68088   void * jresult ;
68089   Dali::Toolkit::Internal::Control *arg1 = 0 ;
68090   Dali::Toolkit::Control *result = 0 ;
68091
68092   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
68093   if (!arg1) {
68094     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Internal::Control & type is null", 0);
68095     return 0;
68096   }
68097   {
68098     try {
68099       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control(*arg1);
68100     } catch (std::out_of_range& e) {
68101       {
68102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68103       };
68104     } catch (std::exception& e) {
68105       {
68106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68107       };
68108     } catch (Dali::DaliException e) {
68109       {
68110         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68111       };
68112     } catch (...) {
68113       {
68114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68115       };
68116     }
68117   }
68118
68119   jresult = (void *)result;
68120   return jresult;
68121 }
68122
68123 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_GetVisualResourceStatus(void * jarg1, int jarg2)
68124 {
68125   int jresult;
68126   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68127   arg1 = (Dali::Toolkit::Control *)jarg1;
68128
68129   if (!arg1) {
68130     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
68131     return 0;
68132   }
68133
68134   Dali::Property::Index arg2 = 0 ;
68135   arg2 = (Dali::Property::Index)jarg2;
68136
68137   Toolkit::Visual::ResourceStatus result;
68138   {
68139     try {
68140       result = arg1->GetVisualResourceStatus(arg2);
68141     } catch (std::out_of_range& e) {
68142       {
68143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68144       };
68145     } catch (std::exception& e) {
68146       {
68147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68148       };
68149     } catch (...) {
68150       {
68151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68152       };
68153     }
68154   }
68155   jresult = (int)(result);
68156   return jresult;
68157 }
68158
68159 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_CreateTransition(void * jarg1, void * jarg2)
68160 {
68161   void * jresult;
68162   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68163   arg1 = (Dali::Toolkit::Control *)jarg1;
68164
68165   Dali::Toolkit::Internal::Control& controlImpl = Dali::Toolkit::Internal::GetImplementation( *arg1 );
68166
68167   Dali::Toolkit::TransitionData *arg2 = 0 ;
68168   Dali::Animation result;
68169
68170   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
68171   if (!arg2) {
68172     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
68173     return 0;
68174   }
68175   {
68176     try {
68177       result = DevelControl::CreateTransition( controlImpl, (Dali::Toolkit::TransitionData const &)*arg2);
68178     } catch (std::out_of_range& e) {
68179       {
68180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68181       };
68182     } catch (std::exception& e) {
68183       {
68184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68185       };
68186     } catch (Dali::DaliException e) {
68187       {
68188         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68189       };
68190     } catch (...) {
68191       {
68192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68193       };
68194     }
68195   }
68196
68197   jresult = new Dali::Animation((const Dali::Animation &)result);
68198   return jresult;
68199 }
68200
68201 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_DoAction(void * jarg1, int jarg2, int jarg3, void * jarg4 )
68202 {
68203   Dali::Toolkit::Control arg1;
68204   Dali::Toolkit::Control *argp1  = (Dali::Toolkit::Control *)jarg1;
68205
68206   if (!argp1) {
68207     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
68208   }
68209   arg1 = *argp1;
68210
68211   Dali::Property::Index arg2 = 0 ;
68212   arg2 = (Dali::Property::Index)jarg2;
68213
68214   Dali::Property::Index arg3 = 0 ;
68215   arg3 = (Dali::Property::Index)jarg3;
68216
68217   Dali::Property::Value arg4;
68218   arg4 = (Dali::Property::Value *)jarg4;
68219
68220   {
68221     try {
68222       DevelControl::DoAction(arg1, arg2, arg3, arg4);
68223     } catch (std::out_of_range& e) {
68224       {
68225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68226       };
68227     } catch (std::exception& e) {
68228       {
68229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68230       };
68231     } catch (...) {
68232       {
68233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68234       };
68235     }
68236   }
68237
68238
68239 }
68240
68241 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetLayout__SWIG_0(void * jarg1) {
68242   void * jresult ;
68243   Dali::Toolkit::Internal::Control *arg1 = 0 ;
68244   Dali::Toolkit::LayoutItem result;
68245
68246   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
68247   if (!arg1) {
68248     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Internal::Control & type is null", 0);
68249     return 0;
68250   }
68251   {
68252     try {
68253       result = Dali::Toolkit::DevelControl::GetLayout(*arg1);
68254     } catch (std::out_of_range& e) {
68255       {
68256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68257       };
68258     } catch (std::exception& e) {
68259       {
68260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68261       };
68262     } catch (...) {
68263       {
68264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68265       };
68266     }
68267   }
68268   jresult = new Dali::Toolkit::LayoutItem((const Dali::Toolkit::LayoutItem &)result);
68269   return jresult;
68270 }
68271
68272
68273 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetLayout__SWIG_1(void * jarg1) {
68274   void * jresult ;
68275   Dali::Toolkit::Control arg1 ;
68276   Dali::Toolkit::Control *argp1 ;
68277   Dali::Toolkit::LayoutItem result;
68278
68279   argp1 = (Dali::Toolkit::Control *)jarg1;
68280   if (!argp1) {
68281     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
68282     return 0;
68283   }
68284   arg1 = *argp1;
68285   {
68286     try {
68287       result = Dali::Toolkit::DevelControl::GetLayout(arg1);
68288     } catch (std::out_of_range& e) {
68289       {
68290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68291       };
68292     } catch (std::exception& e) {
68293       {
68294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68295       };
68296     } catch (...) {
68297       {
68298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68299       };
68300     }
68301   }
68302   jresult = new Dali::Toolkit::LayoutItem((const Dali::Toolkit::LayoutItem &)result);
68303   return jresult;
68304 }
68305
68306 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetLayout__SWIG_0(void * jarg1, void * jarg2) {
68307   Dali::Toolkit::Internal::Control *arg1 = 0 ;
68308   Dali::Toolkit::LayoutItem arg2 ;
68309   Dali::Toolkit::LayoutItem *argp2 ;
68310
68311   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
68312   if (!arg1) {
68313     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Internal::Control & type is null", 0);
68314     return ;
68315   }
68316   argp2 = (Dali::Toolkit::LayoutItem *)jarg2;
68317   if (!argp2) {
68318     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::LayoutItem", 0);
68319     return ;
68320   }
68321   arg2 = *argp2;
68322   {
68323     try {
68324       Dali::Toolkit::DevelControl::SetLayout(*arg1,arg2);
68325     } catch (std::out_of_range& e) {
68326       {
68327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68328       };
68329     } catch (std::exception& e) {
68330       {
68331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68332       };
68333     } catch (...) {
68334       {
68335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68336       };
68337     }
68338   }
68339 }
68340
68341
68342 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetLayout__SWIG_1(void * jarg1, void * jarg2) {
68343   Dali::Toolkit::Control arg1 ;
68344   Dali::Toolkit::LayoutItem arg2 ;
68345   Dali::Toolkit::Control *argp1 ;
68346   Dali::Toolkit::LayoutItem *argp2 ;
68347
68348   argp1 = (Dali::Toolkit::Control *)jarg1;
68349   if (!argp1) {
68350     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
68351     return ;
68352   }
68353   arg1 = *argp1;
68354   argp2 = (Dali::Toolkit::LayoutItem *)jarg2;
68355   if (!argp2) {
68356     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::LayoutItem", 0);
68357     return ;
68358   }
68359   arg2 = *argp2;
68360   {
68361     try {
68362       Dali::Toolkit::DevelControl::SetLayout(arg1,arg2);
68363     } catch (std::out_of_range& e) {
68364       {
68365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68366       };
68367     } catch (std::exception& e) {
68368       {
68369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68370       };
68371     } catch (...) {
68372       {
68373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68374       };
68375     }
68376   }
68377 }
68378
68379 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetLayoutingRequired(void * jarg1, bool jarg2) {
68380   Dali::Toolkit::Control *arg1 = 0 ;
68381
68382   arg1 = (Dali::Toolkit::Control *)jarg1;
68383   if (!arg1) {
68384     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Internal::Control & type is null", 0);
68385     return ;
68386   }
68387
68388   {
68389     try {
68390       Dali::Toolkit::DevelControl::SetLayoutingRequired(*arg1,jarg2);
68391     } catch (std::out_of_range& e) {
68392       {
68393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68394       };
68395     } catch (std::exception& e) {
68396       {
68397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68398       };
68399     } catch (...) {
68400       {
68401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68402       };
68403     }
68404   }
68405 }
68406
68407 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_View_IsLayoutingRequired(void * jarg1) {
68408   unsigned int jresult ;
68409   Dali::Toolkit::Control *arg1 = 0 ;
68410   bool result;
68411
68412   arg1 = (Dali::Toolkit::Control *)jarg1;
68413   if (!arg1) {
68414     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
68415     return 0;
68416   }
68417   {
68418     try {
68419       result = (bool)DevelControl::IsLayoutingRequired( *arg1 );
68420     } catch (std::out_of_range& e) {
68421       {
68422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68423       };
68424     } catch (std::exception& e) {
68425       {
68426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68427       };
68428     } catch (Dali::DaliException e) {
68429       {
68430         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68431       };
68432     } catch (...) {
68433       {
68434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68435       };
68436     }
68437   }
68438
68439   jresult = result;
68440   return jresult;
68441 }
68442
68443 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceReadySignal(void * jarg1) {
68444   void * jresult ;
68445   Dali::Toolkit::Control *arg1 = 0 ;
68446   Dali::Toolkit::Control::ResourceReadySignalType *result = 0 ;
68447
68448   arg1 = (Dali::Toolkit::Control *)jarg1;
68449   if (!arg1) {
68450     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
68451     return 0;
68452   }
68453   {
68454     try {
68455       result = (Dali::Toolkit::Control::ResourceReadySignalType *) &arg1->ResourceReadySignal();
68456     } catch (std::out_of_range& e) {
68457       {
68458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68459       };
68460     } catch (std::exception& e) {
68461       {
68462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68463       };
68464     } catch (Dali::DaliException e) {
68465       {
68466         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68467       };
68468     } catch (...) {
68469       {
68470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68471       };
68472     }
68473   }
68474
68475   jresult = (void *)result;
68476   return jresult;
68477 }
68478
68479
68480 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsResourceReady(void * jarg1) {
68481   unsigned int jresult ;
68482   Dali::Toolkit::Control *arg1 = 0 ;
68483   bool result;
68484
68485   arg1 = (Dali::Toolkit::Control *)jarg1;
68486   if (!arg1) {
68487     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
68488     return 0;
68489   }
68490   {
68491     try {
68492       result = (bool)arg1->IsResourceReady();
68493     } catch (std::out_of_range& e) {
68494       {
68495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68496       };
68497     } catch (std::exception& e) {
68498       {
68499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68500       };
68501     } catch (Dali::DaliException e) {
68502       {
68503         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68504       };
68505     } catch (...) {
68506       {
68507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68508       };
68509     }
68510   }
68511
68512   jresult = result;
68513   return jresult;
68514 }
68515
68516
68517 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusManager() {
68518   void * jresult ;
68519   Dali::Toolkit::KeyInputFocusManager *result = 0 ;
68520
68521   {
68522     try {
68523       result = (Dali::Toolkit::KeyInputFocusManager *)new Dali::Toolkit::KeyInputFocusManager();
68524     } catch (std::out_of_range& e) {
68525       {
68526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68527       };
68528     } catch (std::exception& e) {
68529       {
68530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68531       };
68532     } catch (Dali::DaliException e) {
68533       {
68534         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68535       };
68536     } catch (...) {
68537       {
68538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68539       };
68540     }
68541   }
68542
68543   jresult = (void *)result;
68544   return jresult;
68545 }
68546
68547
68548 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusManager(void * jarg1) {
68549   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68550
68551   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68552   {
68553     try {
68554       delete arg1;
68555     } catch (std::out_of_range& e) {
68556       {
68557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68558       };
68559     } catch (std::exception& e) {
68560       {
68561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68562       };
68563     } catch (Dali::DaliException e) {
68564       {
68565         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68566       };
68567     } catch (...) {
68568       {
68569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68570       };
68571     }
68572   }
68573
68574 }
68575
68576
68577 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_Get() {
68578   void * jresult ;
68579   Dali::Toolkit::KeyInputFocusManager result;
68580
68581   {
68582     try {
68583       result = Dali::Toolkit::KeyInputFocusManager::Get();
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 = new Dali::Toolkit::KeyInputFocusManager((const Dali::Toolkit::KeyInputFocusManager &)result);
68604   return jresult;
68605 }
68606
68607
68608 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SetFocus(void * jarg1, void * jarg2) {
68609   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68610   Dali::Toolkit::Control arg2 ;
68611   Dali::Toolkit::Control *argp2 ;
68612
68613   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68614   argp2 = (Dali::Toolkit::Control *)jarg2;
68615   if (!argp2) {
68616     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
68617     return ;
68618   }
68619   arg2 = *argp2;
68620   {
68621     try {
68622       (arg1)->SetFocus(arg2);
68623     } catch (std::out_of_range& e) {
68624       {
68625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68626       };
68627     } catch (std::exception& e) {
68628       {
68629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68630       };
68631     } catch (Dali::DaliException e) {
68632       {
68633         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68634       };
68635     } catch (...) {
68636       {
68637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68638       };
68639     }
68640   }
68641
68642 }
68643
68644
68645 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_GetCurrentFocusControl(void * jarg1) {
68646   void * jresult ;
68647   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68648   Dali::Toolkit::Control result;
68649
68650   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68651   {
68652     try {
68653       result = ((Dali::Toolkit::KeyInputFocusManager const *)arg1)->GetCurrentFocusControl();
68654     } catch (std::out_of_range& e) {
68655       {
68656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68657       };
68658     } catch (std::exception& e) {
68659       {
68660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68661       };
68662     } catch (Dali::DaliException e) {
68663       {
68664         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68665       };
68666     } catch (...) {
68667       {
68668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68669       };
68670     }
68671   }
68672
68673   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
68674   return jresult;
68675 }
68676
68677
68678 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_RemoveFocus(void * jarg1, void * jarg2) {
68679   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68680   Dali::Toolkit::Control arg2 ;
68681   Dali::Toolkit::Control *argp2 ;
68682
68683   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68684   argp2 = (Dali::Toolkit::Control *)jarg2;
68685   if (!argp2) {
68686     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
68687     return ;
68688   }
68689   arg2 = *argp2;
68690   {
68691     try {
68692       (arg1)->RemoveFocus(arg2);
68693     } catch (std::out_of_range& e) {
68694       {
68695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68696       };
68697     } catch (std::exception& e) {
68698       {
68699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68700       };
68701     } catch (Dali::DaliException e) {
68702       {
68703         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68704       };
68705     } catch (...) {
68706       {
68707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68708       };
68709     }
68710   }
68711
68712 }
68713
68714
68715 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_KeyInputFocusChangedSignal(void * jarg1) {
68716   void * jresult ;
68717   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68718   Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *result = 0 ;
68719
68720   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68721   {
68722     try {
68723       result = (Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *) &(arg1)->KeyInputFocusChangedSignal();
68724     } catch (std::out_of_range& e) {
68725       {
68726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68727       };
68728     } catch (std::exception& e) {
68729       {
68730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68731       };
68732     } catch (Dali::DaliException e) {
68733       {
68734         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68735       };
68736     } catch (...) {
68737       {
68738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68739       };
68740     }
68741   }
68742
68743   jresult = (void *)result;
68744   return jresult;
68745 }
68746
68747
68748 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_0() {
68749   void * jresult ;
68750   Dali::Toolkit::Alignment::Padding *result = 0 ;
68751
68752   {
68753     try {
68754       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding();
68755     } catch (std::out_of_range& e) {
68756       {
68757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68758       };
68759     } catch (std::exception& e) {
68760       {
68761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68762       };
68763     } catch (Dali::DaliException e) {
68764       {
68765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68766       };
68767     } catch (...) {
68768       {
68769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68770       };
68771     }
68772   }
68773
68774   jresult = (void *)result;
68775   return jresult;
68776 }
68777
68778
68779 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
68780   void * jresult ;
68781   float arg1 ;
68782   float arg2 ;
68783   float arg3 ;
68784   float arg4 ;
68785   Dali::Toolkit::Alignment::Padding *result = 0 ;
68786
68787   arg1 = (float)jarg1;
68788   arg2 = (float)jarg2;
68789   arg3 = (float)jarg3;
68790   arg4 = (float)jarg4;
68791   {
68792     try {
68793       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding(arg1,arg2,arg3,arg4);
68794     } catch (std::out_of_range& e) {
68795       {
68796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68797       };
68798     } catch (std::exception& e) {
68799       {
68800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68801       };
68802     } catch (Dali::DaliException e) {
68803       {
68804         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68805       };
68806     } catch (...) {
68807       {
68808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68809       };
68810     }
68811   }
68812
68813   jresult = (void *)result;
68814   return jresult;
68815 }
68816
68817
68818 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_set(void * jarg1, float jarg2) {
68819   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68820   float arg2 ;
68821
68822   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68823   arg2 = (float)jarg2;
68824   if (arg1) (arg1)->left = arg2;
68825 }
68826
68827
68828 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_get(void * jarg1) {
68829   float jresult ;
68830   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68831   float result;
68832
68833   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68834   result = (float) ((arg1)->left);
68835   jresult = result;
68836   return jresult;
68837 }
68838
68839
68840 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_set(void * jarg1, float jarg2) {
68841   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68842   float arg2 ;
68843
68844   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68845   arg2 = (float)jarg2;
68846   if (arg1) (arg1)->right = arg2;
68847 }
68848
68849
68850 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_get(void * jarg1) {
68851   float jresult ;
68852   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68853   float result;
68854
68855   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68856   result = (float) ((arg1)->right);
68857   jresult = result;
68858   return jresult;
68859 }
68860
68861
68862 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_set(void * jarg1, float jarg2) {
68863   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68864   float arg2 ;
68865
68866   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68867   arg2 = (float)jarg2;
68868   if (arg1) (arg1)->top = arg2;
68869 }
68870
68871
68872 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_get(void * jarg1) {
68873   float jresult ;
68874   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68875   float result;
68876
68877   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68878   result = (float) ((arg1)->top);
68879   jresult = result;
68880   return jresult;
68881 }
68882
68883
68884 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_set(void * jarg1, float jarg2) {
68885   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68886   float arg2 ;
68887
68888   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68889   arg2 = (float)jarg2;
68890   if (arg1) (arg1)->bottom = arg2;
68891 }
68892
68893
68894 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_get(void * jarg1) {
68895   float jresult ;
68896   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68897   float result;
68898
68899   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68900   result = (float) ((arg1)->bottom);
68901   jresult = result;
68902   return jresult;
68903 }
68904
68905
68906 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment_Padding(void * jarg1) {
68907   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68908
68909   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68910   {
68911     try {
68912       delete arg1;
68913     } catch (std::out_of_range& e) {
68914       {
68915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68916       };
68917     } catch (std::exception& e) {
68918       {
68919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68920       };
68921     } catch (Dali::DaliException e) {
68922       {
68923         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68924       };
68925     } catch (...) {
68926       {
68927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68928       };
68929     }
68930   }
68931
68932 }
68933
68934
68935 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_0() {
68936   void * jresult ;
68937   Dali::Toolkit::Alignment *result = 0 ;
68938
68939   {
68940     try {
68941       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment();
68942     } catch (std::out_of_range& e) {
68943       {
68944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68945       };
68946     } catch (std::exception& e) {
68947       {
68948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68949       };
68950     } catch (Dali::DaliException e) {
68951       {
68952         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68953       };
68954     } catch (...) {
68955       {
68956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68957       };
68958     }
68959   }
68960
68961   jresult = (void *)result;
68962   return jresult;
68963 }
68964
68965
68966 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_0(int jarg1, int jarg2) {
68967   void * jresult ;
68968   Dali::Toolkit::Alignment::Type arg1 ;
68969   Dali::Toolkit::Alignment::Type arg2 ;
68970   Dali::Toolkit::Alignment result;
68971
68972   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
68973   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
68974   {
68975     try {
68976       result = Dali::Toolkit::Alignment::New(arg1,arg2);
68977     } catch (std::out_of_range& e) {
68978       {
68979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68980       };
68981     } catch (std::exception& e) {
68982       {
68983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68984       };
68985     } catch (Dali::DaliException e) {
68986       {
68987         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68988       };
68989     } catch (...) {
68990       {
68991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68992       };
68993     }
68994   }
68995
68996   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
68997   return jresult;
68998 }
68999
69000
69001 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_1(int jarg1) {
69002   void * jresult ;
69003   Dali::Toolkit::Alignment::Type arg1 ;
69004   Dali::Toolkit::Alignment result;
69005
69006   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
69007   {
69008     try {
69009       result = Dali::Toolkit::Alignment::New(arg1);
69010     } catch (std::out_of_range& e) {
69011       {
69012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69013       };
69014     } catch (std::exception& e) {
69015       {
69016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69017       };
69018     } catch (Dali::DaliException e) {
69019       {
69020         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69021       };
69022     } catch (...) {
69023       {
69024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69025       };
69026     }
69027   }
69028
69029   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
69030   return jresult;
69031 }
69032
69033
69034 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_2() {
69035   void * jresult ;
69036   Dali::Toolkit::Alignment result;
69037
69038   {
69039     try {
69040       result = Dali::Toolkit::Alignment::New();
69041     } catch (std::out_of_range& e) {
69042       {
69043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69044       };
69045     } catch (std::exception& e) {
69046       {
69047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69048       };
69049     } catch (Dali::DaliException e) {
69050       {
69051         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69052       };
69053     } catch (...) {
69054       {
69055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69056       };
69057     }
69058   }
69059
69060   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
69061   return jresult;
69062 }
69063
69064
69065 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_1(void * jarg1) {
69066   void * jresult ;
69067   Dali::Toolkit::Alignment *arg1 = 0 ;
69068   Dali::Toolkit::Alignment *result = 0 ;
69069
69070   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69071   if (!arg1) {
69072     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
69073     return 0;
69074   }
69075   {
69076     try {
69077       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment((Dali::Toolkit::Alignment const &)*arg1);
69078     } catch (std::out_of_range& e) {
69079       {
69080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69081       };
69082     } catch (std::exception& e) {
69083       {
69084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69085       };
69086     } catch (Dali::DaliException e) {
69087       {
69088         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69089       };
69090     } catch (...) {
69091       {
69092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69093       };
69094     }
69095   }
69096
69097   jresult = (void *)result;
69098   return jresult;
69099 }
69100
69101
69102 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment(void * jarg1) {
69103   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69104
69105   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69106   {
69107     try {
69108       delete arg1;
69109     } catch (std::out_of_range& e) {
69110       {
69111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69112       };
69113     } catch (std::exception& e) {
69114       {
69115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69116       };
69117     } catch (Dali::DaliException e) {
69118       {
69119         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69120       };
69121     } catch (...) {
69122       {
69123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69124       };
69125     }
69126   }
69127
69128 }
69129
69130
69131 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_DownCast(void * jarg1) {
69132   void * jresult ;
69133   Dali::BaseHandle arg1 ;
69134   Dali::BaseHandle *argp1 ;
69135   Dali::Toolkit::Alignment result;
69136
69137   argp1 = (Dali::BaseHandle *)jarg1;
69138   if (!argp1) {
69139     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
69140     return 0;
69141   }
69142   arg1 = *argp1;
69143   {
69144     try {
69145       result = Dali::Toolkit::Alignment::DownCast(arg1);
69146     } catch (std::out_of_range& e) {
69147       {
69148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69149       };
69150     } catch (std::exception& e) {
69151       {
69152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69153       };
69154     } catch (Dali::DaliException e) {
69155       {
69156         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69157       };
69158     } catch (...) {
69159       {
69160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69161       };
69162     }
69163   }
69164
69165   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
69166   return jresult;
69167 }
69168
69169
69170 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetAlignmentType(void * jarg1, int jarg2) {
69171   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69172   Dali::Toolkit::Alignment::Type arg2 ;
69173
69174   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69175   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
69176   {
69177     try {
69178       (arg1)->SetAlignmentType(arg2);
69179     } catch (std::out_of_range& e) {
69180       {
69181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69182       };
69183     } catch (std::exception& e) {
69184       {
69185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69186       };
69187     } catch (Dali::DaliException e) {
69188       {
69189         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69190       };
69191     } catch (...) {
69192       {
69193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69194       };
69195     }
69196   }
69197
69198 }
69199
69200
69201 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetAlignmentType(void * jarg1) {
69202   int jresult ;
69203   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69204   Dali::Toolkit::Alignment::Type result;
69205
69206   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69207   {
69208     try {
69209       result = (Dali::Toolkit::Alignment::Type)((Dali::Toolkit::Alignment const *)arg1)->GetAlignmentType();
69210     } catch (std::out_of_range& e) {
69211       {
69212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69213       };
69214     } catch (std::exception& e) {
69215       {
69216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69217       };
69218     } catch (Dali::DaliException e) {
69219       {
69220         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69221       };
69222     } catch (...) {
69223       {
69224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69225       };
69226     }
69227   }
69228
69229   jresult = (int)result;
69230   return jresult;
69231 }
69232
69233
69234 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetScaling(void * jarg1, int jarg2) {
69235   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69236   Dali::Toolkit::Alignment::Scaling arg2 ;
69237
69238   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69239   arg2 = (Dali::Toolkit::Alignment::Scaling)jarg2;
69240   {
69241     try {
69242       (arg1)->SetScaling(arg2);
69243     } catch (std::out_of_range& e) {
69244       {
69245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69246       };
69247     } catch (std::exception& e) {
69248       {
69249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69250       };
69251     } catch (Dali::DaliException e) {
69252       {
69253         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69254       };
69255     } catch (...) {
69256       {
69257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69258       };
69259     }
69260   }
69261
69262 }
69263
69264
69265 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetScaling(void * jarg1) {
69266   int jresult ;
69267   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69268   Dali::Toolkit::Alignment::Scaling result;
69269
69270   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69271   {
69272     try {
69273       result = (Dali::Toolkit::Alignment::Scaling)((Dali::Toolkit::Alignment const *)arg1)->GetScaling();
69274     } catch (std::out_of_range& e) {
69275       {
69276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69277       };
69278     } catch (std::exception& e) {
69279       {
69280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69281       };
69282     } catch (Dali::DaliException e) {
69283       {
69284         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69285       };
69286     } catch (...) {
69287       {
69288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69289       };
69290     }
69291   }
69292
69293   jresult = (int)result;
69294   return jresult;
69295 }
69296
69297
69298 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetPadding(void * jarg1, void * jarg2) {
69299   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69300   Dali::Toolkit::Alignment::Padding *arg2 = 0 ;
69301
69302   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69303   arg2 = (Dali::Toolkit::Alignment::Padding *)jarg2;
69304   if (!arg2) {
69305     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment::Padding const & type is null", 0);
69306     return ;
69307   }
69308   {
69309     try {
69310       (arg1)->SetPadding((Dali::Toolkit::Alignment::Padding const &)*arg2);
69311     } catch (std::out_of_range& e) {
69312       {
69313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69314       };
69315     } catch (std::exception& e) {
69316       {
69317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69318       };
69319     } catch (Dali::DaliException e) {
69320       {
69321         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69322       };
69323     } catch (...) {
69324       {
69325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69326       };
69327     }
69328   }
69329
69330 }
69331
69332
69333 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_GetPadding(void * jarg1) {
69334   void * jresult ;
69335   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69336   Dali::Toolkit::Alignment::Padding *result = 0 ;
69337
69338   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69339   {
69340     try {
69341       result = (Dali::Toolkit::Alignment::Padding *) &((Dali::Toolkit::Alignment const *)arg1)->GetPadding();
69342     } catch (std::out_of_range& e) {
69343       {
69344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69345       };
69346     } catch (std::exception& e) {
69347       {
69348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69349       };
69350     } catch (Dali::DaliException e) {
69351       {
69352         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69353       };
69354     } catch (...) {
69355       {
69356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69357       };
69358     }
69359   }
69360
69361   jresult = (void *)result;
69362   return jresult;
69363 }
69364
69365
69366 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_Assign(void * jarg1, void * jarg2) {
69367   void * jresult ;
69368   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69369   Dali::Toolkit::Alignment *arg2 = 0 ;
69370   Dali::Toolkit::Alignment *result = 0 ;
69371
69372   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69373   arg2 = (Dali::Toolkit::Alignment *)jarg2;
69374   if (!arg2) {
69375     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
69376     return 0;
69377   }
69378   {
69379     try {
69380       result = (Dali::Toolkit::Alignment *) &(arg1)->operator =((Dali::Toolkit::Alignment const &)*arg2);
69381     } catch (std::out_of_range& e) {
69382       {
69383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69384       };
69385     } catch (std::exception& e) {
69386       {
69387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69388       };
69389     } catch (Dali::DaliException e) {
69390       {
69391         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69392       };
69393     } catch (...) {
69394       {
69395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69396       };
69397     }
69398   }
69399
69400   jresult = (void *)result;
69401   return jresult;
69402 }
69403
69404
69405 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_DISABLED_get() {
69406   int jresult ;
69407   int result;
69408
69409   result = (int)Dali::Toolkit::Button::Property::DISABLED;
69410   jresult = (int)result;
69411   return jresult;
69412 }
69413
69414
69415 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_AUTO_REPEATING_get() {
69416   int jresult ;
69417   int result;
69418
69419   result = (int)Dali::Toolkit::Button::Property::AUTO_REPEATING;
69420   jresult = (int)result;
69421   return jresult;
69422 }
69423
69424
69425 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_INITIAL_AUTO_REPEATING_DELAY_get() {
69426   int jresult ;
69427   int result;
69428
69429   result = (int)Dali::Toolkit::Button::Property::INITIAL_AUTO_REPEATING_DELAY;
69430   jresult = (int)result;
69431   return jresult;
69432 }
69433
69434
69435 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_NEXT_AUTO_REPEATING_DELAY_get() {
69436   int jresult ;
69437   int result;
69438
69439   result = (int)Dali::Toolkit::Button::Property::NEXT_AUTO_REPEATING_DELAY;
69440   jresult = (int)result;
69441   return jresult;
69442 }
69443
69444
69445 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_TOGGLABLE_get() {
69446   int jresult ;
69447   int result;
69448
69449   result = (int)Dali::Toolkit::Button::Property::TOGGLABLE;
69450   jresult = (int)result;
69451   return jresult;
69452 }
69453
69454
69455 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_get() {
69456   int jresult ;
69457   int result;
69458
69459   result = (int)Dali::Toolkit::Button::Property::SELECTED;
69460   jresult = (int)result;
69461   return jresult;
69462 }
69463
69464
69465 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_UNSELECTED_COLOR_get() {
69466   int jresult ;
69467   int result;
69468
69469   result = (int)Dali::Toolkit::Button::Property::UNSELECTED_COLOR;
69470   jresult = (int)result;
69471   return jresult;
69472 }
69473
69474
69475 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_COLOR_get() {
69476   int jresult ;
69477   int result;
69478
69479   result = (int)Dali::Toolkit::Button::Property::SELECTED_COLOR;
69480   jresult = (int)result;
69481   return jresult;
69482 }
69483
69484
69485 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_get() {
69486   int jresult ;
69487   int result;
69488
69489   result = (int)Dali::Toolkit::Button::Property::LABEL;
69490   jresult = (int)result;
69491   return jresult;
69492 }
69493
69494
69495 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_TEXT_get() {
69496   int jresult ;
69497   int result;
69498
69499   result = (int)Dali::Toolkit::Button::Property::LABEL_TEXT;
69500   jresult = (int)result;
69501   return jresult;
69502 }
69503
69504
69505 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button_Property() {
69506   void * jresult ;
69507   Dali::Toolkit::Button::Property *result = 0 ;
69508
69509   {
69510     try {
69511       result = (Dali::Toolkit::Button::Property *)new Dali::Toolkit::Button::Property();
69512     } catch (std::out_of_range& e) {
69513       {
69514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69515       };
69516     } catch (std::exception& e) {
69517       {
69518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69519       };
69520     } catch (Dali::DaliException e) {
69521       {
69522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69523       };
69524     } catch (...) {
69525       {
69526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69527       };
69528     }
69529   }
69530
69531   jresult = (void *)result;
69532   return jresult;
69533 }
69534
69535
69536 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button_Property(void * jarg1) {
69537   Dali::Toolkit::Button::Property *arg1 = (Dali::Toolkit::Button::Property *) 0 ;
69538
69539   arg1 = (Dali::Toolkit::Button::Property *)jarg1;
69540   {
69541     try {
69542       delete arg1;
69543     } catch (std::out_of_range& e) {
69544       {
69545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69546       };
69547     } catch (std::exception& e) {
69548       {
69549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69550       };
69551     } catch (Dali::DaliException e) {
69552       {
69553         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69554       };
69555     } catch (...) {
69556       {
69557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69558       };
69559     }
69560   }
69561
69562 }
69563
69564
69565 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_0() {
69566   void * jresult ;
69567   Dali::Toolkit::Button *result = 0 ;
69568
69569   {
69570     try {
69571       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button();
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 = (void *)result;
69592   return jresult;
69593 }
69594
69595
69596 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_1(void * jarg1) {
69597   void * jresult ;
69598   Dali::Toolkit::Button *arg1 = 0 ;
69599   Dali::Toolkit::Button *result = 0 ;
69600
69601   arg1 = (Dali::Toolkit::Button *)jarg1;
69602   if (!arg1) {
69603     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
69604     return 0;
69605   }
69606   {
69607     try {
69608       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button((Dali::Toolkit::Button const &)*arg1);
69609     } catch (std::out_of_range& e) {
69610       {
69611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69612       };
69613     } catch (std::exception& e) {
69614       {
69615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69616       };
69617     } catch (Dali::DaliException e) {
69618       {
69619         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69620       };
69621     } catch (...) {
69622       {
69623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69624       };
69625     }
69626   }
69627
69628   jresult = (void *)result;
69629   return jresult;
69630 }
69631
69632
69633 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_Assign(void * jarg1, void * jarg2) {
69634   void * jresult ;
69635   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69636   Dali::Toolkit::Button *arg2 = 0 ;
69637   Dali::Toolkit::Button *result = 0 ;
69638
69639   arg1 = (Dali::Toolkit::Button *)jarg1;
69640   arg2 = (Dali::Toolkit::Button *)jarg2;
69641   if (!arg2) {
69642     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
69643     return 0;
69644   }
69645   {
69646     try {
69647       result = (Dali::Toolkit::Button *) &(arg1)->operator =((Dali::Toolkit::Button const &)*arg2);
69648     } catch (std::out_of_range& e) {
69649       {
69650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69651       };
69652     } catch (std::exception& e) {
69653       {
69654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69655       };
69656     } catch (Dali::DaliException e) {
69657       {
69658         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69659       };
69660     } catch (...) {
69661       {
69662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69663       };
69664     }
69665   }
69666
69667   jresult = (void *)result;
69668   return jresult;
69669 }
69670
69671
69672 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_DownCast(void * jarg1) {
69673   void * jresult ;
69674   Dali::BaseHandle arg1 ;
69675   Dali::BaseHandle *argp1 ;
69676   Dali::Toolkit::Button result;
69677
69678   argp1 = (Dali::BaseHandle *)jarg1;
69679   if (!argp1) {
69680     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
69681     return 0;
69682   }
69683   arg1 = *argp1;
69684   {
69685     try {
69686       result = Dali::Toolkit::Button::DownCast(arg1);
69687     } catch (std::out_of_range& e) {
69688       {
69689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69690       };
69691     } catch (std::exception& e) {
69692       {
69693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69694       };
69695     } catch (Dali::DaliException e) {
69696       {
69697         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69698       };
69699     } catch (...) {
69700       {
69701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69702       };
69703     }
69704   }
69705
69706   jresult = new Dali::Toolkit::Button((const Dali::Toolkit::Button &)result);
69707   return jresult;
69708 }
69709
69710
69711 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button(void * jarg1) {
69712   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69713
69714   arg1 = (Dali::Toolkit::Button *)jarg1;
69715   {
69716     try {
69717       delete arg1;
69718     } catch (std::out_of_range& e) {
69719       {
69720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69721       };
69722     } catch (std::exception& e) {
69723       {
69724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69725       };
69726     } catch (Dali::DaliException e) {
69727       {
69728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69729       };
69730     } catch (...) {
69731       {
69732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69733       };
69734     }
69735   }
69736
69737 }
69738
69739
69740 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsDisabled(void * jarg1) {
69741   unsigned int jresult ;
69742   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69743   bool result;
69744
69745   arg1 = (Dali::Toolkit::Button *)jarg1;
69746   {
69747     try {
69748       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsDisabled();
69749     } catch (std::out_of_range& e) {
69750       {
69751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69752       };
69753     } catch (std::exception& e) {
69754       {
69755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69756       };
69757     } catch (Dali::DaliException e) {
69758       {
69759         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69760       };
69761     } catch (...) {
69762       {
69763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69764       };
69765     }
69766   }
69767
69768   jresult = result;
69769   return jresult;
69770 }
69771
69772
69773 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsAutoRepeating(void * jarg1) {
69774   unsigned int jresult ;
69775   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69776   bool result;
69777
69778   arg1 = (Dali::Toolkit::Button *)jarg1;
69779   {
69780     try {
69781       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsAutoRepeating();
69782     } catch (std::out_of_range& e) {
69783       {
69784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69785       };
69786     } catch (std::exception& e) {
69787       {
69788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69789       };
69790     } catch (Dali::DaliException e) {
69791       {
69792         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69793       };
69794     } catch (...) {
69795       {
69796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69797       };
69798     }
69799   }
69800
69801   jresult = result;
69802   return jresult;
69803 }
69804
69805
69806 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetInitialAutoRepeatingDelay(void * jarg1) {
69807   float jresult ;
69808   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69809   float result;
69810
69811   arg1 = (Dali::Toolkit::Button *)jarg1;
69812   {
69813     try {
69814       result = (float)((Dali::Toolkit::Button const *)arg1)->GetInitialAutoRepeatingDelay();
69815     } catch (std::out_of_range& e) {
69816       {
69817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69818       };
69819     } catch (std::exception& e) {
69820       {
69821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69822       };
69823     } catch (Dali::DaliException e) {
69824       {
69825         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69826       };
69827     } catch (...) {
69828       {
69829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69830       };
69831     }
69832   }
69833
69834   jresult = result;
69835   return jresult;
69836 }
69837
69838
69839 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetNextAutoRepeatingDelay(void * jarg1) {
69840   float jresult ;
69841   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69842   float result;
69843
69844   arg1 = (Dali::Toolkit::Button *)jarg1;
69845   {
69846     try {
69847       result = (float)((Dali::Toolkit::Button const *)arg1)->GetNextAutoRepeatingDelay();
69848     } catch (std::out_of_range& e) {
69849       {
69850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69851       };
69852     } catch (std::exception& e) {
69853       {
69854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69855       };
69856     } catch (Dali::DaliException e) {
69857       {
69858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69859       };
69860     } catch (...) {
69861       {
69862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69863       };
69864     }
69865   }
69866
69867   jresult = result;
69868   return jresult;
69869 }
69870
69871
69872 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsTogglableButton(void * jarg1) {
69873   unsigned int jresult ;
69874   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69875   bool result;
69876
69877   arg1 = (Dali::Toolkit::Button *)jarg1;
69878   {
69879     try {
69880       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsTogglableButton();
69881     } catch (std::out_of_range& e) {
69882       {
69883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69884       };
69885     } catch (std::exception& e) {
69886       {
69887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69888       };
69889     } catch (Dali::DaliException e) {
69890       {
69891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69892       };
69893     } catch (...) {
69894       {
69895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69896       };
69897     }
69898   }
69899
69900   jresult = result;
69901   return jresult;
69902 }
69903
69904
69905 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsSelected(void * jarg1) {
69906   unsigned int jresult ;
69907   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69908   bool result;
69909
69910   arg1 = (Dali::Toolkit::Button *)jarg1;
69911   {
69912     try {
69913       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsSelected();
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 = result;
69934   return jresult;
69935 }
69936
69937
69938 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetAnimationTime(void * jarg1) {
69939   float jresult ;
69940   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69941   float result;
69942
69943   arg1 = (Dali::Toolkit::Button *)jarg1;
69944   {
69945     try {
69946       result = (float)((Dali::Toolkit::Button const *)arg1)->GetAnimationTime();
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 = result;
69967   return jresult;
69968 }
69969
69970
69971 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Button_GetLabelText(void * jarg1) {
69972   char * jresult ;
69973   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69974   std::string result;
69975
69976   arg1 = (Dali::Toolkit::Button *)jarg1;
69977   {
69978     try {
69979       result = ((Dali::Toolkit::Button const *)arg1)->GetLabelText();
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 = SWIG_csharp_string_callback((&result)->c_str());
70000   return jresult;
70001 }
70002
70003
70004 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetLabel(void * jarg1, void * jarg2) {
70005   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70006   Dali::Actor arg2 ;
70007   Dali::Actor *argp2 ;
70008
70009   arg1 = (Dali::Toolkit::Button *)jarg1;
70010   argp2 = (Dali::Actor *)jarg2;
70011   if (!argp2) {
70012     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70013     return ;
70014   }
70015   arg2 = *argp2;
70016   {
70017     try {
70018       (arg1)->SetLabel(arg2);
70019     } catch (std::out_of_range& e) {
70020       {
70021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70022       };
70023     } catch (std::exception& e) {
70024       {
70025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70026       };
70027     } catch (Dali::DaliException e) {
70028       {
70029         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70030       };
70031     } catch (...) {
70032       {
70033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70034       };
70035     }
70036   }
70037
70038 }
70039
70040
70041 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetButtonImage(void * jarg1, void * jarg2) {
70042   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70043   Dali::Image arg2 ;
70044   Dali::Image *argp2 ;
70045
70046   arg1 = (Dali::Toolkit::Button *)jarg1;
70047   argp2 = (Dali::Image *)jarg2;
70048   if (!argp2) {
70049     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
70050     return ;
70051   }
70052   arg2 = *argp2;
70053   {
70054     try {
70055       (arg1)->SetButtonImage(arg2);
70056     } catch (std::out_of_range& e) {
70057       {
70058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70059       };
70060     } catch (std::exception& e) {
70061       {
70062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70063       };
70064     } catch (Dali::DaliException e) {
70065       {
70066         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70067       };
70068     } catch (...) {
70069       {
70070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70071       };
70072     }
70073   }
70074
70075 }
70076
70077
70078 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetSelectedImage(void * jarg1, void * jarg2) {
70079   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70080   Dali::Image arg2 ;
70081   Dali::Image *argp2 ;
70082
70083   arg1 = (Dali::Toolkit::Button *)jarg1;
70084   argp2 = (Dali::Image *)jarg2;
70085   if (!argp2) {
70086     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
70087     return ;
70088   }
70089   arg2 = *argp2;
70090   {
70091     try {
70092       (arg1)->SetSelectedImage(arg2);
70093     } catch (std::out_of_range& e) {
70094       {
70095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70096       };
70097     } catch (std::exception& e) {
70098       {
70099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70100       };
70101     } catch (Dali::DaliException e) {
70102       {
70103         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70104       };
70105     } catch (...) {
70106       {
70107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70108       };
70109     }
70110   }
70111
70112 }
70113
70114
70115 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_GetButtonImage(void * jarg1) {
70116   void * jresult ;
70117   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70118   Dali::Actor result;
70119
70120   arg1 = (Dali::Toolkit::Button *)jarg1;
70121   {
70122     try {
70123       result = ((Dali::Toolkit::Button const *)arg1)->GetButtonImage();
70124     } catch (std::out_of_range& e) {
70125       {
70126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70127       };
70128     } catch (std::exception& e) {
70129       {
70130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70131       };
70132     } catch (Dali::DaliException e) {
70133       {
70134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70135       };
70136     } catch (...) {
70137       {
70138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70139       };
70140     }
70141   }
70142
70143   jresult = new Dali::Actor((const Dali::Actor &)result);
70144   return jresult;
70145 }
70146
70147
70148 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_GetSelectedImage(void * jarg1) {
70149   void * jresult ;
70150   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70151   Dali::Actor result;
70152
70153   arg1 = (Dali::Toolkit::Button *)jarg1;
70154   {
70155     try {
70156       result = ((Dali::Toolkit::Button const *)arg1)->GetSelectedImage();
70157     } catch (std::out_of_range& e) {
70158       {
70159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70160       };
70161     } catch (std::exception& e) {
70162       {
70163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70164       };
70165     } catch (Dali::DaliException e) {
70166       {
70167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70168       };
70169     } catch (...) {
70170       {
70171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70172       };
70173     }
70174   }
70175
70176   jresult = new Dali::Actor((const Dali::Actor &)result);
70177   return jresult;
70178 }
70179
70180
70181 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_PressedSignal(void * jarg1) {
70182   void * jresult ;
70183   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70184   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
70185
70186   arg1 = (Dali::Toolkit::Button *)jarg1;
70187   {
70188     try {
70189       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->PressedSignal();
70190     } catch (std::out_of_range& e) {
70191       {
70192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70193       };
70194     } catch (std::exception& e) {
70195       {
70196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70197       };
70198     } catch (Dali::DaliException e) {
70199       {
70200         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70201       };
70202     } catch (...) {
70203       {
70204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70205       };
70206     }
70207   }
70208
70209   jresult = (void *)result;
70210   return jresult;
70211 }
70212
70213
70214 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ReleasedSignal(void * jarg1) {
70215   void * jresult ;
70216   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70217   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
70218
70219   arg1 = (Dali::Toolkit::Button *)jarg1;
70220   {
70221     try {
70222       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ReleasedSignal();
70223     } catch (std::out_of_range& e) {
70224       {
70225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70226       };
70227     } catch (std::exception& e) {
70228       {
70229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70230       };
70231     } catch (Dali::DaliException e) {
70232       {
70233         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70234       };
70235     } catch (...) {
70236       {
70237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70238       };
70239     }
70240   }
70241
70242   jresult = (void *)result;
70243   return jresult;
70244 }
70245
70246
70247 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ClickedSignal(void * jarg1) {
70248   void * jresult ;
70249   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70250   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
70251
70252   arg1 = (Dali::Toolkit::Button *)jarg1;
70253   {
70254     try {
70255       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ClickedSignal();
70256     } catch (std::out_of_range& e) {
70257       {
70258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70259       };
70260     } catch (std::exception& e) {
70261       {
70262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70263       };
70264     } catch (Dali::DaliException e) {
70265       {
70266         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70267       };
70268     } catch (...) {
70269       {
70270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70271       };
70272     }
70273   }
70274
70275   jresult = (void *)result;
70276   return jresult;
70277 }
70278
70279
70280 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_StateChangedSignal(void * jarg1) {
70281   void * jresult ;
70282   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70283   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
70284
70285   arg1 = (Dali::Toolkit::Button *)jarg1;
70286   {
70287     try {
70288       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->StateChangedSignal();
70289     } catch (std::out_of_range& e) {
70290       {
70291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70292       };
70293     } catch (std::exception& e) {
70294       {
70295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70296       };
70297     } catch (Dali::DaliException e) {
70298       {
70299         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70300       };
70301     } catch (...) {
70302       {
70303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70304       };
70305     }
70306   }
70307
70308   jresult = (void *)result;
70309   return jresult;
70310 }
70311
70312
70313 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_0() {
70314   void * jresult ;
70315   Dali::Toolkit::CheckBoxButton *result = 0 ;
70316
70317   {
70318     try {
70319       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton();
70320     } catch (std::out_of_range& e) {
70321       {
70322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70323       };
70324     } catch (std::exception& e) {
70325       {
70326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70327       };
70328     } catch (Dali::DaliException e) {
70329       {
70330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70331       };
70332     } catch (...) {
70333       {
70334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70335       };
70336     }
70337   }
70338
70339   jresult = (void *)result;
70340   return jresult;
70341 }
70342
70343
70344 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_1(void * jarg1) {
70345   void * jresult ;
70346   Dali::Toolkit::CheckBoxButton *arg1 = 0 ;
70347   Dali::Toolkit::CheckBoxButton *result = 0 ;
70348
70349   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
70350   if (!arg1) {
70351     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
70352     return 0;
70353   }
70354   {
70355     try {
70356       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton((Dali::Toolkit::CheckBoxButton const &)*arg1);
70357     } catch (std::out_of_range& e) {
70358       {
70359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70360       };
70361     } catch (std::exception& e) {
70362       {
70363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70364       };
70365     } catch (Dali::DaliException e) {
70366       {
70367         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70368       };
70369     } catch (...) {
70370       {
70371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70372       };
70373     }
70374   }
70375
70376   jresult = (void *)result;
70377   return jresult;
70378 }
70379
70380
70381 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_Assign(void * jarg1, void * jarg2) {
70382   void * jresult ;
70383   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
70384   Dali::Toolkit::CheckBoxButton *arg2 = 0 ;
70385   Dali::Toolkit::CheckBoxButton *result = 0 ;
70386
70387   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
70388   arg2 = (Dali::Toolkit::CheckBoxButton *)jarg2;
70389   if (!arg2) {
70390     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
70391     return 0;
70392   }
70393   {
70394     try {
70395       result = (Dali::Toolkit::CheckBoxButton *) &(arg1)->operator =((Dali::Toolkit::CheckBoxButton const &)*arg2);
70396     } catch (std::out_of_range& e) {
70397       {
70398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70399       };
70400     } catch (std::exception& e) {
70401       {
70402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70403       };
70404     } catch (Dali::DaliException e) {
70405       {
70406         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70407       };
70408     } catch (...) {
70409       {
70410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70411       };
70412     }
70413   }
70414
70415   jresult = (void *)result;
70416   return jresult;
70417 }
70418
70419
70420 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CheckBoxButton(void * jarg1) {
70421   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
70422
70423   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
70424   {
70425     try {
70426       delete arg1;
70427     } catch (std::out_of_range& e) {
70428       {
70429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70430       };
70431     } catch (std::exception& e) {
70432       {
70433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70434       };
70435     } catch (Dali::DaliException e) {
70436       {
70437         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70438       };
70439     } catch (...) {
70440       {
70441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70442       };
70443     }
70444   }
70445
70446 }
70447
70448
70449 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_New() {
70450   void * jresult ;
70451   Dali::Toolkit::CheckBoxButton result;
70452
70453   {
70454     try {
70455       result = Dali::Toolkit::CheckBoxButton::New();
70456     } catch (std::out_of_range& e) {
70457       {
70458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70459       };
70460     } catch (std::exception& e) {
70461       {
70462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70463       };
70464     } catch (Dali::DaliException e) {
70465       {
70466         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70467       };
70468     } catch (...) {
70469       {
70470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70471       };
70472     }
70473   }
70474
70475   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
70476   return jresult;
70477 }
70478
70479
70480 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_DownCast(void * jarg1) {
70481   void * jresult ;
70482   Dali::BaseHandle arg1 ;
70483   Dali::BaseHandle *argp1 ;
70484   Dali::Toolkit::CheckBoxButton result;
70485
70486   argp1 = (Dali::BaseHandle *)jarg1;
70487   if (!argp1) {
70488     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
70489     return 0;
70490   }
70491   arg1 = *argp1;
70492   {
70493     try {
70494       result = Dali::Toolkit::CheckBoxButton::DownCast(arg1);
70495     } catch (std::out_of_range& e) {
70496       {
70497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70498       };
70499     } catch (std::exception& e) {
70500       {
70501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70502       };
70503     } catch (Dali::DaliException e) {
70504       {
70505         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70506       };
70507     } catch (...) {
70508       {
70509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70510       };
70511     }
70512   }
70513
70514   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
70515   return jresult;
70516 }
70517
70518
70519 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_UNSELECTED_ICON_get() {
70520   int jresult ;
70521   int result;
70522
70523   result = (int)Dali::Toolkit::PushButton::Property::UNSELECTED_ICON;
70524   jresult = (int)result;
70525   return jresult;
70526 }
70527
70528
70529 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_SELECTED_ICON_get() {
70530   int jresult ;
70531   int result;
70532
70533   result = (int)Dali::Toolkit::PushButton::Property::SELECTED_ICON;
70534   jresult = (int)result;
70535   return jresult;
70536 }
70537
70538
70539 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_ALIGNMENT_get() {
70540   int jresult ;
70541   int result;
70542
70543   result = (int)Dali::Toolkit::PushButton::Property::ICON_ALIGNMENT;
70544   jresult = (int)result;
70545   return jresult;
70546 }
70547
70548
70549 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_LABEL_PADDING_get() {
70550   int jresult ;
70551   int result;
70552
70553   result = (int)Dali::Toolkit::PushButton::Property::LABEL_PADDING;
70554   jresult = (int)result;
70555   return jresult;
70556 }
70557
70558
70559 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_PADDING_get() {
70560   int jresult ;
70561   int result;
70562
70563   result = (int)Dali::Toolkit::PushButton::Property::ICON_PADDING;
70564   jresult = (int)result;
70565   return jresult;
70566 }
70567
70568
70569 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton_Property() {
70570   void * jresult ;
70571   Dali::Toolkit::PushButton::Property *result = 0 ;
70572
70573   {
70574     try {
70575       result = (Dali::Toolkit::PushButton::Property *)new Dali::Toolkit::PushButton::Property();
70576     } catch (std::out_of_range& e) {
70577       {
70578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70579       };
70580     } catch (std::exception& e) {
70581       {
70582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70583       };
70584     } catch (Dali::DaliException e) {
70585       {
70586         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70587       };
70588     } catch (...) {
70589       {
70590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70591       };
70592     }
70593   }
70594
70595   jresult = (void *)result;
70596   return jresult;
70597 }
70598
70599
70600 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton_Property(void * jarg1) {
70601   Dali::Toolkit::PushButton::Property *arg1 = (Dali::Toolkit::PushButton::Property *) 0 ;
70602
70603   arg1 = (Dali::Toolkit::PushButton::Property *)jarg1;
70604   {
70605     try {
70606       delete arg1;
70607     } catch (std::out_of_range& e) {
70608       {
70609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70610       };
70611     } catch (std::exception& e) {
70612       {
70613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70614       };
70615     } catch (Dali::DaliException e) {
70616       {
70617         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70618       };
70619     } catch (...) {
70620       {
70621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70622       };
70623     }
70624   }
70625
70626 }
70627
70628
70629 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_0() {
70630   void * jresult ;
70631   Dali::Toolkit::PushButton *result = 0 ;
70632
70633   {
70634     try {
70635       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton();
70636     } catch (std::out_of_range& e) {
70637       {
70638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70639       };
70640     } catch (std::exception& e) {
70641       {
70642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70643       };
70644     } catch (Dali::DaliException e) {
70645       {
70646         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70647       };
70648     } catch (...) {
70649       {
70650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70651       };
70652     }
70653   }
70654
70655   jresult = (void *)result;
70656   return jresult;
70657 }
70658
70659
70660 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_1(void * jarg1) {
70661   void * jresult ;
70662   Dali::Toolkit::PushButton *arg1 = 0 ;
70663   Dali::Toolkit::PushButton *result = 0 ;
70664
70665   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70666   if (!arg1) {
70667     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
70668     return 0;
70669   }
70670   {
70671     try {
70672       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton((Dali::Toolkit::PushButton const &)*arg1);
70673     } catch (std::out_of_range& e) {
70674       {
70675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70676       };
70677     } catch (std::exception& e) {
70678       {
70679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70680       };
70681     } catch (Dali::DaliException e) {
70682       {
70683         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70684       };
70685     } catch (...) {
70686       {
70687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70688       };
70689     }
70690   }
70691
70692   jresult = (void *)result;
70693   return jresult;
70694 }
70695
70696
70697 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_Assign(void * jarg1, void * jarg2) {
70698   void * jresult ;
70699   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70700   Dali::Toolkit::PushButton *arg2 = 0 ;
70701   Dali::Toolkit::PushButton *result = 0 ;
70702
70703   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70704   arg2 = (Dali::Toolkit::PushButton *)jarg2;
70705   if (!arg2) {
70706     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
70707     return 0;
70708   }
70709   {
70710     try {
70711       result = (Dali::Toolkit::PushButton *) &(arg1)->operator =((Dali::Toolkit::PushButton const &)*arg2);
70712     } catch (std::out_of_range& e) {
70713       {
70714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70715       };
70716     } catch (std::exception& e) {
70717       {
70718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70719       };
70720     } catch (Dali::DaliException e) {
70721       {
70722         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70723       };
70724     } catch (...) {
70725       {
70726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70727       };
70728     }
70729   }
70730
70731   jresult = (void *)result;
70732   return jresult;
70733 }
70734
70735
70736 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton(void * jarg1) {
70737   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70738
70739   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70740   {
70741     try {
70742       delete arg1;
70743     } catch (std::out_of_range& e) {
70744       {
70745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70746       };
70747     } catch (std::exception& e) {
70748       {
70749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70750       };
70751     } catch (Dali::DaliException e) {
70752       {
70753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70754       };
70755     } catch (...) {
70756       {
70757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70758       };
70759     }
70760   }
70761
70762 }
70763
70764
70765 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_New() {
70766   void * jresult ;
70767   Dali::Toolkit::PushButton result;
70768
70769   {
70770     try {
70771       result = Dali::Toolkit::PushButton::New();
70772     } catch (std::out_of_range& e) {
70773       {
70774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70775       };
70776     } catch (std::exception& e) {
70777       {
70778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70779       };
70780     } catch (Dali::DaliException e) {
70781       {
70782         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70783       };
70784     } catch (...) {
70785       {
70786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70787       };
70788     }
70789   }
70790
70791   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
70792   return jresult;
70793 }
70794
70795
70796 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_DownCast(void * jarg1) {
70797   void * jresult ;
70798   Dali::BaseHandle arg1 ;
70799   Dali::BaseHandle *argp1 ;
70800   Dali::Toolkit::PushButton result;
70801
70802   argp1 = (Dali::BaseHandle *)jarg1;
70803   if (!argp1) {
70804     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
70805     return 0;
70806   }
70807   arg1 = *argp1;
70808   {
70809     try {
70810       result = Dali::Toolkit::PushButton::DownCast(arg1);
70811     } catch (std::out_of_range& e) {
70812       {
70813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70814       };
70815     } catch (std::exception& e) {
70816       {
70817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70818       };
70819     } catch (Dali::DaliException e) {
70820       {
70821         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70822       };
70823     } catch (...) {
70824       {
70825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70826       };
70827     }
70828   }
70829
70830   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
70831   return jresult;
70832 }
70833
70834
70835 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetButtonImage__SWIG_0_0(void * jarg1, void * jarg2) {
70836   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70837   Dali::Image arg2 ;
70838   Dali::Image *argp2 ;
70839
70840   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70841   argp2 = (Dali::Image *)jarg2;
70842   if (!argp2) {
70843     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
70844     return ;
70845   }
70846   arg2 = *argp2;
70847   {
70848     try {
70849       (arg1)->SetButtonImage(arg2);
70850     } catch (std::out_of_range& e) {
70851       {
70852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70853       };
70854     } catch (std::exception& e) {
70855       {
70856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70857       };
70858     } catch (Dali::DaliException e) {
70859       {
70860         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70861       };
70862     } catch (...) {
70863       {
70864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70865       };
70866     }
70867   }
70868
70869 }
70870
70871
70872 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetButtonImage__SWIG_1(void * jarg1, void * jarg2) {
70873   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70874   Dali::Actor arg2 ;
70875   Dali::Actor *argp2 ;
70876
70877   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70878   argp2 = (Dali::Actor *)jarg2;
70879   if (!argp2) {
70880     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70881     return ;
70882   }
70883   arg2 = *argp2;
70884   {
70885     try {
70886       (arg1)->SetButtonImage(arg2);
70887     } catch (std::out_of_range& e) {
70888       {
70889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70890       };
70891     } catch (std::exception& e) {
70892       {
70893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70894       };
70895     } catch (Dali::DaliException e) {
70896       {
70897         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70898       };
70899     } catch (...) {
70900       {
70901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70902       };
70903     }
70904   }
70905
70906 }
70907
70908
70909 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetBackgroundImage(void * jarg1, void * jarg2) {
70910   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70911   Dali::Actor arg2 ;
70912   Dali::Actor *argp2 ;
70913
70914   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70915   argp2 = (Dali::Actor *)jarg2;
70916   if (!argp2) {
70917     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70918     return ;
70919   }
70920   arg2 = *argp2;
70921   {
70922     try {
70923       (arg1)->SetBackgroundImage(arg2);
70924     } catch (std::out_of_range& e) {
70925       {
70926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70927       };
70928     } catch (std::exception& e) {
70929       {
70930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70931       };
70932     } catch (Dali::DaliException e) {
70933       {
70934         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70935       };
70936     } catch (...) {
70937       {
70938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70939       };
70940     }
70941   }
70942
70943 }
70944
70945
70946 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedImage__SWIG_0_0(void * jarg1, void * jarg2) {
70947   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70948   Dali::Image arg2 ;
70949   Dali::Image *argp2 ;
70950
70951   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70952   argp2 = (Dali::Image *)jarg2;
70953   if (!argp2) {
70954     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
70955     return ;
70956   }
70957   arg2 = *argp2;
70958   {
70959     try {
70960       (arg1)->SetSelectedImage(arg2);
70961     } catch (std::out_of_range& e) {
70962       {
70963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70964       };
70965     } catch (std::exception& e) {
70966       {
70967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70968       };
70969     } catch (Dali::DaliException e) {
70970       {
70971         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70972       };
70973     } catch (...) {
70974       {
70975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70976       };
70977     }
70978   }
70979
70980 }
70981
70982
70983 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedImage__SWIG_1(void * jarg1, void * jarg2) {
70984   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70985   Dali::Actor arg2 ;
70986   Dali::Actor *argp2 ;
70987
70988   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70989   argp2 = (Dali::Actor *)jarg2;
70990   if (!argp2) {
70991     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70992     return ;
70993   }
70994   arg2 = *argp2;
70995   {
70996     try {
70997       (arg1)->SetSelectedImage(arg2);
70998     } catch (std::out_of_range& e) {
70999       {
71000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71001       };
71002     } catch (std::exception& e) {
71003       {
71004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71005       };
71006     } catch (Dali::DaliException e) {
71007       {
71008         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71009       };
71010     } catch (...) {
71011       {
71012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71013       };
71014     }
71015   }
71016
71017 }
71018
71019
71020 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedBackgroundImage(void * jarg1, void * jarg2) {
71021   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
71022   Dali::Actor arg2 ;
71023   Dali::Actor *argp2 ;
71024
71025   arg1 = (Dali::Toolkit::PushButton *)jarg1;
71026   argp2 = (Dali::Actor *)jarg2;
71027   if (!argp2) {
71028     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71029     return ;
71030   }
71031   arg2 = *argp2;
71032   {
71033     try {
71034       (arg1)->SetSelectedBackgroundImage(arg2);
71035     } catch (std::out_of_range& e) {
71036       {
71037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71038       };
71039     } catch (std::exception& e) {
71040       {
71041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71042       };
71043     } catch (Dali::DaliException e) {
71044       {
71045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71046       };
71047     } catch (...) {
71048       {
71049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71050       };
71051     }
71052   }
71053
71054 }
71055
71056
71057 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledBackgroundImage(void * jarg1, void * jarg2) {
71058   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
71059   Dali::Actor arg2 ;
71060   Dali::Actor *argp2 ;
71061
71062   arg1 = (Dali::Toolkit::PushButton *)jarg1;
71063   argp2 = (Dali::Actor *)jarg2;
71064   if (!argp2) {
71065     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71066     return ;
71067   }
71068   arg2 = *argp2;
71069   {
71070     try {
71071       (arg1)->SetDisabledBackgroundImage(arg2);
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_PushButton_SetDisabledImage(void * jarg1, void * jarg2) {
71095   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
71096   Dali::Actor arg2 ;
71097   Dali::Actor *argp2 ;
71098
71099   arg1 = (Dali::Toolkit::PushButton *)jarg1;
71100   argp2 = (Dali::Actor *)jarg2;
71101   if (!argp2) {
71102     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71103     return ;
71104   }
71105   arg2 = *argp2;
71106   {
71107     try {
71108       (arg1)->SetDisabledImage(arg2);
71109     } catch (std::out_of_range& e) {
71110       {
71111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71112       };
71113     } catch (std::exception& e) {
71114       {
71115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71116       };
71117     } catch (Dali::DaliException e) {
71118       {
71119         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71120       };
71121     } catch (...) {
71122       {
71123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71124       };
71125     }
71126   }
71127
71128 }
71129
71130
71131 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledSelectedImage(void * jarg1, void * jarg2) {
71132   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
71133   Dali::Actor arg2 ;
71134   Dali::Actor *argp2 ;
71135
71136   arg1 = (Dali::Toolkit::PushButton *)jarg1;
71137   argp2 = (Dali::Actor *)jarg2;
71138   if (!argp2) {
71139     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71140     return ;
71141   }
71142   arg2 = *argp2;
71143   {
71144     try {
71145       (arg1)->SetDisabledSelectedImage(arg2);
71146     } catch (std::out_of_range& e) {
71147       {
71148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71149       };
71150     } catch (std::exception& e) {
71151       {
71152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71153       };
71154     } catch (Dali::DaliException e) {
71155       {
71156         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71157       };
71158     } catch (...) {
71159       {
71160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71161       };
71162     }
71163   }
71164
71165 }
71166
71167
71168 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_0() {
71169   void * jresult ;
71170   Dali::Toolkit::RadioButton *result = 0 ;
71171
71172   {
71173     try {
71174       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton();
71175     } catch (std::out_of_range& e) {
71176       {
71177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71178       };
71179     } catch (std::exception& e) {
71180       {
71181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71182       };
71183     } catch (Dali::DaliException e) {
71184       {
71185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71186       };
71187     } catch (...) {
71188       {
71189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71190       };
71191     }
71192   }
71193
71194   jresult = (void *)result;
71195   return jresult;
71196 }
71197
71198
71199 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_1(void * jarg1) {
71200   void * jresult ;
71201   Dali::Toolkit::RadioButton *arg1 = 0 ;
71202   Dali::Toolkit::RadioButton *result = 0 ;
71203
71204   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
71205   if (!arg1) {
71206     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
71207     return 0;
71208   }
71209   {
71210     try {
71211       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton((Dali::Toolkit::RadioButton const &)*arg1);
71212     } catch (std::out_of_range& e) {
71213       {
71214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71215       };
71216     } catch (std::exception& e) {
71217       {
71218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71219       };
71220     } catch (Dali::DaliException e) {
71221       {
71222         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71223       };
71224     } catch (...) {
71225       {
71226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71227       };
71228     }
71229   }
71230
71231   jresult = (void *)result;
71232   return jresult;
71233 }
71234
71235
71236 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_Assign(void * jarg1, void * jarg2) {
71237   void * jresult ;
71238   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
71239   Dali::Toolkit::RadioButton *arg2 = 0 ;
71240   Dali::Toolkit::RadioButton *result = 0 ;
71241
71242   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
71243   arg2 = (Dali::Toolkit::RadioButton *)jarg2;
71244   if (!arg2) {
71245     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
71246     return 0;
71247   }
71248   {
71249     try {
71250       result = (Dali::Toolkit::RadioButton *) &(arg1)->operator =((Dali::Toolkit::RadioButton const &)*arg2);
71251     } catch (std::out_of_range& e) {
71252       {
71253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71254       };
71255     } catch (std::exception& e) {
71256       {
71257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71258       };
71259     } catch (Dali::DaliException e) {
71260       {
71261         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71262       };
71263     } catch (...) {
71264       {
71265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71266       };
71267     }
71268   }
71269
71270   jresult = (void *)result;
71271   return jresult;
71272 }
71273
71274
71275 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RadioButton(void * jarg1) {
71276   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
71277
71278   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
71279   {
71280     try {
71281       delete arg1;
71282     } catch (std::out_of_range& e) {
71283       {
71284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71285       };
71286     } catch (std::exception& e) {
71287       {
71288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71289       };
71290     } catch (Dali::DaliException e) {
71291       {
71292         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71293       };
71294     } catch (...) {
71295       {
71296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71297       };
71298     }
71299   }
71300
71301 }
71302
71303
71304 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_0() {
71305   void * jresult ;
71306   Dali::Toolkit::RadioButton result;
71307
71308   {
71309     try {
71310       result = Dali::Toolkit::RadioButton::New();
71311     } catch (std::out_of_range& e) {
71312       {
71313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71314       };
71315     } catch (std::exception& e) {
71316       {
71317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71318       };
71319     } catch (Dali::DaliException e) {
71320       {
71321         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71322       };
71323     } catch (...) {
71324       {
71325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71326       };
71327     }
71328   }
71329
71330   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
71331   return jresult;
71332 }
71333
71334
71335 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_1(char * jarg1) {
71336   void * jresult ;
71337   std::string *arg1 = 0 ;
71338   Dali::Toolkit::RadioButton result;
71339
71340   if (!jarg1) {
71341     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
71342     return 0;
71343   }
71344   std::string arg1_str(jarg1);
71345   arg1 = &arg1_str;
71346   {
71347     try {
71348       result = Dali::Toolkit::RadioButton::New((std::string const &)*arg1);
71349     } catch (std::out_of_range& e) {
71350       {
71351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71352       };
71353     } catch (std::exception& e) {
71354       {
71355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71356       };
71357     } catch (Dali::DaliException e) {
71358       {
71359         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71360       };
71361     } catch (...) {
71362       {
71363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71364       };
71365     }
71366   }
71367
71368   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
71369
71370   //argout typemap for const std::string&
71371
71372   return jresult;
71373 }
71374
71375
71376 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_DownCast(void * jarg1) {
71377   void * jresult ;
71378   Dali::BaseHandle arg1 ;
71379   Dali::BaseHandle *argp1 ;
71380   Dali::Toolkit::RadioButton result;
71381
71382   argp1 = (Dali::BaseHandle *)jarg1;
71383   if (!argp1) {
71384     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
71385     return 0;
71386   }
71387   arg1 = *argp1;
71388   {
71389     try {
71390       result = Dali::Toolkit::RadioButton::DownCast(arg1);
71391     } catch (std::out_of_range& e) {
71392       {
71393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71394       };
71395     } catch (std::exception& e) {
71396       {
71397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71398       };
71399     } catch (Dali::DaliException e) {
71400       {
71401         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71402       };
71403     } catch (...) {
71404       {
71405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71406       };
71407     }
71408   }
71409
71410   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
71411   return jresult;
71412 }
71413
71414
71415 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_CONTENT_DIRECTION_get() {
71416   int jresult ;
71417   int result;
71418
71419   result = (int)Dali::Toolkit::FlexContainer::Property::CONTENT_DIRECTION;
71420   jresult = (int)result;
71421   return jresult;
71422 }
71423
71424
71425 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_DIRECTION_get() {
71426   int jresult ;
71427   int result;
71428
71429   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_DIRECTION;
71430   jresult = (int)result;
71431   return jresult;
71432 }
71433
71434
71435 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_WRAP_get() {
71436   int jresult ;
71437   int result;
71438
71439   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_WRAP;
71440   jresult = (int)result;
71441   return jresult;
71442 }
71443
71444
71445 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_JUSTIFY_CONTENT_get() {
71446   int jresult ;
71447   int result;
71448
71449   result = (int)Dali::Toolkit::FlexContainer::Property::JUSTIFY_CONTENT;
71450   jresult = (int)result;
71451   return jresult;
71452 }
71453
71454
71455 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_ITEMS_get() {
71456   int jresult ;
71457   int result;
71458
71459   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_ITEMS;
71460   jresult = (int)result;
71461   return jresult;
71462 }
71463
71464
71465 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_CONTENT_get() {
71466   int jresult ;
71467   int result;
71468
71469   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_CONTENT;
71470   jresult = (int)result;
71471   return jresult;
71472 }
71473
71474
71475 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_Property() {
71476   void * jresult ;
71477   Dali::Toolkit::FlexContainer::Property *result = 0 ;
71478
71479   {
71480     try {
71481       result = (Dali::Toolkit::FlexContainer::Property *)new Dali::Toolkit::FlexContainer::Property();
71482     } catch (std::out_of_range& e) {
71483       {
71484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71485       };
71486     } catch (std::exception& e) {
71487       {
71488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71489       };
71490     } catch (Dali::DaliException e) {
71491       {
71492         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71493       };
71494     } catch (...) {
71495       {
71496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71497       };
71498     }
71499   }
71500
71501   jresult = (void *)result;
71502   return jresult;
71503 }
71504
71505
71506 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_Property(void * jarg1) {
71507   Dali::Toolkit::FlexContainer::Property *arg1 = (Dali::Toolkit::FlexContainer::Property *) 0 ;
71508
71509   arg1 = (Dali::Toolkit::FlexContainer::Property *)jarg1;
71510   {
71511     try {
71512       delete arg1;
71513     } catch (std::out_of_range& e) {
71514       {
71515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71516       };
71517     } catch (std::exception& e) {
71518       {
71519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71520       };
71521     } catch (Dali::DaliException e) {
71522       {
71523         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71524       };
71525     } catch (...) {
71526       {
71527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71528       };
71529     }
71530   }
71531
71532 }
71533
71534
71535 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_get() {
71536   int jresult ;
71537   int result;
71538
71539   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX;
71540   jresult = (int)result;
71541   return jresult;
71542 }
71543
71544
71545 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_ALIGN_SELF_get() {
71546   int jresult ;
71547   int result;
71548
71549   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::ALIGN_SELF;
71550   jresult = (int)result;
71551   return jresult;
71552 }
71553
71554
71555 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_MARGIN_get() {
71556   int jresult ;
71557   int result;
71558
71559   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX_MARGIN;
71560   jresult = (int)result;
71561   return jresult;
71562 }
71563
71564
71565 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_ChildProperty() {
71566   void * jresult ;
71567   Dali::Toolkit::FlexContainer::ChildProperty *result = 0 ;
71568
71569   {
71570     try {
71571       result = (Dali::Toolkit::FlexContainer::ChildProperty *)new Dali::Toolkit::FlexContainer::ChildProperty();
71572     } catch (std::out_of_range& e) {
71573       {
71574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71575       };
71576     } catch (std::exception& e) {
71577       {
71578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71579       };
71580     } catch (Dali::DaliException e) {
71581       {
71582         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71583       };
71584     } catch (...) {
71585       {
71586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71587       };
71588     }
71589   }
71590
71591   jresult = (void *)result;
71592   return jresult;
71593 }
71594
71595
71596 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_ChildProperty(void * jarg1) {
71597   Dali::Toolkit::FlexContainer::ChildProperty *arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *) 0 ;
71598
71599   arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *)jarg1;
71600   {
71601     try {
71602       delete arg1;
71603     } catch (std::out_of_range& e) {
71604       {
71605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71606       };
71607     } catch (std::exception& e) {
71608       {
71609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71610       };
71611     } catch (Dali::DaliException e) {
71612       {
71613         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71614       };
71615     } catch (...) {
71616       {
71617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71618       };
71619     }
71620   }
71621
71622 }
71623
71624
71625 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_0() {
71626   void * jresult ;
71627   Dali::Toolkit::FlexContainer *result = 0 ;
71628
71629   {
71630     try {
71631       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer();
71632     } catch (std::out_of_range& e) {
71633       {
71634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71635       };
71636     } catch (std::exception& e) {
71637       {
71638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71639       };
71640     } catch (Dali::DaliException e) {
71641       {
71642         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71643       };
71644     } catch (...) {
71645       {
71646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71647       };
71648     }
71649   }
71650
71651   jresult = (void *)result;
71652   return jresult;
71653 }
71654
71655
71656 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_1(void * jarg1) {
71657   void * jresult ;
71658   Dali::Toolkit::FlexContainer *arg1 = 0 ;
71659   Dali::Toolkit::FlexContainer *result = 0 ;
71660
71661   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
71662   if (!arg1) {
71663     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
71664     return 0;
71665   }
71666   {
71667     try {
71668       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer((Dali::Toolkit::FlexContainer const &)*arg1);
71669     } catch (std::out_of_range& e) {
71670       {
71671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71672       };
71673     } catch (std::exception& e) {
71674       {
71675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71676       };
71677     } catch (Dali::DaliException e) {
71678       {
71679         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71680       };
71681     } catch (...) {
71682       {
71683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71684       };
71685     }
71686   }
71687
71688   jresult = (void *)result;
71689   return jresult;
71690 }
71691
71692
71693 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_Assign(void * jarg1, void * jarg2) {
71694   void * jresult ;
71695   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
71696   Dali::Toolkit::FlexContainer *arg2 = 0 ;
71697   Dali::Toolkit::FlexContainer *result = 0 ;
71698
71699   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
71700   arg2 = (Dali::Toolkit::FlexContainer *)jarg2;
71701   if (!arg2) {
71702     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
71703     return 0;
71704   }
71705   {
71706     try {
71707       result = (Dali::Toolkit::FlexContainer *) &(arg1)->operator =((Dali::Toolkit::FlexContainer const &)*arg2);
71708     } catch (std::out_of_range& e) {
71709       {
71710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71711       };
71712     } catch (std::exception& e) {
71713       {
71714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71715       };
71716     } catch (Dali::DaliException e) {
71717       {
71718         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71719       };
71720     } catch (...) {
71721       {
71722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71723       };
71724     }
71725   }
71726
71727   jresult = (void *)result;
71728   return jresult;
71729 }
71730
71731
71732 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer(void * jarg1) {
71733   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
71734
71735   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
71736   {
71737     try {
71738       delete arg1;
71739     } catch (std::out_of_range& e) {
71740       {
71741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71742       };
71743     } catch (std::exception& e) {
71744       {
71745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71746       };
71747     } catch (Dali::DaliException e) {
71748       {
71749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71750       };
71751     } catch (...) {
71752       {
71753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71754       };
71755     }
71756   }
71757
71758 }
71759
71760
71761 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_New() {
71762   void * jresult ;
71763   Dali::Toolkit::FlexContainer result;
71764
71765   {
71766     try {
71767       result = Dali::Toolkit::FlexContainer::New();
71768     } catch (std::out_of_range& e) {
71769       {
71770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71771       };
71772     } catch (std::exception& e) {
71773       {
71774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71775       };
71776     } catch (Dali::DaliException e) {
71777       {
71778         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71779       };
71780     } catch (...) {
71781       {
71782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71783       };
71784     }
71785   }
71786
71787   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
71788   return jresult;
71789 }
71790
71791
71792 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_DownCast(void * jarg1) {
71793   void * jresult ;
71794   Dali::BaseHandle arg1 ;
71795   Dali::BaseHandle *argp1 ;
71796   Dali::Toolkit::FlexContainer result;
71797
71798   argp1 = (Dali::BaseHandle *)jarg1;
71799   if (!argp1) {
71800     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
71801     return 0;
71802   }
71803   arg1 = *argp1;
71804   {
71805     try {
71806       result = Dali::Toolkit::FlexContainer::DownCast(arg1);
71807     } catch (std::out_of_range& e) {
71808       {
71809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71810       };
71811     } catch (std::exception& e) {
71812       {
71813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71814       };
71815     } catch (Dali::DaliException e) {
71816       {
71817         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71818       };
71819     } catch (...) {
71820       {
71821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71822       };
71823     }
71824   }
71825
71826   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
71827   return jresult;
71828 }
71829
71830
71831 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_RESOURCE_URL_get() {
71832   int jresult ;
71833   int result;
71834
71835   result = (int)Dali::Toolkit::ImageView::Property::RESOURCE_URL;
71836   jresult = (int)result;
71837   return jresult;
71838 }
71839
71840
71841 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_IMAGE_get() {
71842   int jresult ;
71843   int result;
71844
71845   result = (int)Dali::Toolkit::ImageView::Property::IMAGE;
71846   jresult = (int)result;
71847   return jresult;
71848 }
71849
71850
71851 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PRE_MULTIPLIED_ALPHA_get() {
71852   int jresult ;
71853   int result;
71854
71855   result = (int)Dali::Toolkit::ImageView::Property::PRE_MULTIPLIED_ALPHA;
71856   jresult = (int)result;
71857   return jresult;
71858 }
71859
71860
71861 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PIXEL_AREA_get() {
71862   int jresult ;
71863   int result;
71864
71865   result = (int)Dali::Toolkit::ImageView::Property::PIXEL_AREA;
71866   jresult = (int)result;
71867   return jresult;
71868 }
71869
71870
71871 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView_Property() {
71872   void * jresult ;
71873   Dali::Toolkit::ImageView::Property *result = 0 ;
71874
71875   {
71876     try {
71877       result = (Dali::Toolkit::ImageView::Property *)new Dali::Toolkit::ImageView::Property();
71878     } catch (std::out_of_range& e) {
71879       {
71880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71881       };
71882     } catch (std::exception& e) {
71883       {
71884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71885       };
71886     } catch (Dali::DaliException e) {
71887       {
71888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71889       };
71890     } catch (...) {
71891       {
71892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71893       };
71894     }
71895   }
71896
71897   jresult = (void *)result;
71898   return jresult;
71899 }
71900
71901
71902 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView_Property(void * jarg1) {
71903   Dali::Toolkit::ImageView::Property *arg1 = (Dali::Toolkit::ImageView::Property *) 0 ;
71904
71905   arg1 = (Dali::Toolkit::ImageView::Property *)jarg1;
71906   {
71907     try {
71908       delete arg1;
71909     } catch (std::out_of_range& e) {
71910       {
71911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71912       };
71913     } catch (std::exception& e) {
71914       {
71915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71916       };
71917     } catch (Dali::DaliException e) {
71918       {
71919         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71920       };
71921     } catch (...) {
71922       {
71923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71924       };
71925     }
71926   }
71927
71928 }
71929
71930
71931 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_0() {
71932   void * jresult ;
71933   Dali::Toolkit::ImageView *result = 0 ;
71934
71935   {
71936     try {
71937       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView();
71938     } catch (std::out_of_range& e) {
71939       {
71940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71941       };
71942     } catch (std::exception& e) {
71943       {
71944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71945       };
71946     } catch (Dali::DaliException e) {
71947       {
71948         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71949       };
71950     } catch (...) {
71951       {
71952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71953       };
71954     }
71955   }
71956
71957   jresult = (void *)result;
71958   return jresult;
71959 }
71960
71961
71962 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_0() {
71963   void * jresult ;
71964   Dali::Toolkit::ImageView result;
71965
71966   {
71967     try {
71968       result = Dali::Toolkit::ImageView::New();
71969     } catch (std::out_of_range& e) {
71970       {
71971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71972       };
71973     } catch (std::exception& e) {
71974       {
71975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71976       };
71977     } catch (Dali::DaliException e) {
71978       {
71979         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71980       };
71981     } catch (...) {
71982       {
71983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71984       };
71985     }
71986   }
71987
71988   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
71989   return jresult;
71990 }
71991
71992
71993 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_1(void * jarg1) {
71994   void * jresult ;
71995   Dali::Image arg1 ;
71996   Dali::Image *argp1 ;
71997   Dali::Toolkit::ImageView result;
71998
71999   argp1 = (Dali::Image *)jarg1;
72000   if (!argp1) {
72001     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
72002     return 0;
72003   }
72004   arg1 = *argp1;
72005   {
72006     try {
72007       result = Dali::Toolkit::ImageView::New(arg1);
72008     } catch (std::out_of_range& e) {
72009       {
72010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72011       };
72012     } catch (std::exception& e) {
72013       {
72014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72015       };
72016     } catch (Dali::DaliException e) {
72017       {
72018         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72019       };
72020     } catch (...) {
72021       {
72022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72023       };
72024     }
72025   }
72026
72027   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
72028   return jresult;
72029 }
72030
72031
72032 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_2(char * jarg1) {
72033   void * jresult ;
72034   std::string *arg1 = 0 ;
72035   Dali::Toolkit::ImageView result;
72036
72037   if (!jarg1) {
72038     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72039     return 0;
72040   }
72041   std::string arg1_str(jarg1);
72042   arg1 = &arg1_str;
72043   {
72044     try {
72045       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1);
72046     } catch (std::out_of_range& e) {
72047       {
72048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72049       };
72050     } catch (std::exception& e) {
72051       {
72052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72053       };
72054     } catch (Dali::DaliException e) {
72055       {
72056         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72057       };
72058     } catch (...) {
72059       {
72060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72061       };
72062     }
72063   }
72064
72065   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
72066
72067   //argout typemap for const std::string&
72068
72069   return jresult;
72070 }
72071
72072
72073 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_3(char * jarg1, void * jarg2) {
72074   void * jresult ;
72075   std::string *arg1 = 0 ;
72076   Dali::ImageDimensions arg2 ;
72077   Dali::ImageDimensions *argp2 ;
72078   Dali::Toolkit::ImageView result;
72079
72080   if (!jarg1) {
72081     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72082     return 0;
72083   }
72084   std::string arg1_str(jarg1);
72085   arg1 = &arg1_str;
72086   argp2 = (Dali::ImageDimensions *)jarg2;
72087   if (!argp2) {
72088     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
72089     return 0;
72090   }
72091   arg2 = *argp2;
72092   {
72093     try {
72094       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1,arg2);
72095     } catch (std::out_of_range& e) {
72096       {
72097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72098       };
72099     } catch (std::exception& e) {
72100       {
72101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72102       };
72103     } catch (Dali::DaliException e) {
72104       {
72105         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72106       };
72107     } catch (...) {
72108       {
72109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72110       };
72111     }
72112   }
72113
72114   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
72115
72116   //argout typemap for const std::string&
72117
72118   return jresult;
72119 }
72120
72121
72122 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView(void * jarg1) {
72123   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
72124
72125   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72126   {
72127     try {
72128       delete arg1;
72129     } catch (std::out_of_range& e) {
72130       {
72131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72132       };
72133     } catch (std::exception& e) {
72134       {
72135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72136       };
72137     } catch (Dali::DaliException e) {
72138       {
72139         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72140       };
72141     } catch (...) {
72142       {
72143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72144       };
72145     }
72146   }
72147
72148 }
72149
72150
72151 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_1(void * jarg1) {
72152   void * jresult ;
72153   Dali::Toolkit::ImageView *arg1 = 0 ;
72154   Dali::Toolkit::ImageView *result = 0 ;
72155
72156   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72157   if (!arg1) {
72158     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
72159     return 0;
72160   }
72161   {
72162     try {
72163       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView((Dali::Toolkit::ImageView const &)*arg1);
72164     } catch (std::out_of_range& e) {
72165       {
72166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72167       };
72168     } catch (std::exception& e) {
72169       {
72170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72171       };
72172     } catch (Dali::DaliException e) {
72173       {
72174         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72175       };
72176     } catch (...) {
72177       {
72178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72179       };
72180     }
72181   }
72182
72183   jresult = (void *)result;
72184   return jresult;
72185 }
72186
72187
72188 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_Assign(void * jarg1, void * jarg2) {
72189   void * jresult ;
72190   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
72191   Dali::Toolkit::ImageView *arg2 = 0 ;
72192   Dali::Toolkit::ImageView *result = 0 ;
72193
72194   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72195   arg2 = (Dali::Toolkit::ImageView *)jarg2;
72196   if (!arg2) {
72197     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
72198     return 0;
72199   }
72200   {
72201     try {
72202       result = (Dali::Toolkit::ImageView *) &(arg1)->operator =((Dali::Toolkit::ImageView const &)*arg2);
72203     } catch (std::out_of_range& e) {
72204       {
72205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72206       };
72207     } catch (std::exception& e) {
72208       {
72209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72210       };
72211     } catch (Dali::DaliException e) {
72212       {
72213         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72214       };
72215     } catch (...) {
72216       {
72217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72218       };
72219     }
72220   }
72221
72222   jresult = (void *)result;
72223   return jresult;
72224 }
72225
72226
72227 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_DownCast(void * jarg1) {
72228   void * jresult ;
72229   Dali::BaseHandle arg1 ;
72230   Dali::BaseHandle *argp1 ;
72231   Dali::Toolkit::ImageView result;
72232
72233   argp1 = (Dali::BaseHandle *)jarg1;
72234   if (!argp1) {
72235     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
72236     return 0;
72237   }
72238   arg1 = *argp1;
72239   {
72240     try {
72241       result = Dali::Toolkit::ImageView::DownCast(arg1);
72242     } catch (std::out_of_range& e) {
72243       {
72244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72245       };
72246     } catch (std::exception& e) {
72247       {
72248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72249       };
72250     } catch (Dali::DaliException e) {
72251       {
72252         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72253       };
72254     } catch (...) {
72255       {
72256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72257       };
72258     }
72259   }
72260
72261   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
72262   return jresult;
72263 }
72264
72265
72266 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_0(void * jarg1, void * jarg2) {
72267   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
72268   Dali::Image arg2 ;
72269   Dali::Image *argp2 ;
72270
72271   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72272   argp2 = (Dali::Image *)jarg2;
72273   if (!argp2) {
72274     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
72275     return ;
72276   }
72277   arg2 = *argp2;
72278   {
72279     try {
72280       (arg1)->SetImage(arg2);
72281     } catch (std::out_of_range& e) {
72282       {
72283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72284       };
72285     } catch (std::exception& e) {
72286       {
72287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72288       };
72289     } catch (Dali::DaliException e) {
72290       {
72291         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72292       };
72293     } catch (...) {
72294       {
72295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72296       };
72297     }
72298   }
72299
72300 }
72301
72302
72303 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_1(void * jarg1, char * jarg2) {
72304   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
72305   std::string *arg2 = 0 ;
72306
72307   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72308   if (!jarg2) {
72309     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72310     return ;
72311   }
72312   std::string arg2_str(jarg2);
72313   arg2 = &arg2_str;
72314   {
72315     try {
72316       (arg1)->SetImage((std::string const &)*arg2);
72317     } catch (std::out_of_range& e) {
72318       {
72319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72320       };
72321     } catch (std::exception& e) {
72322       {
72323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72324       };
72325     } catch (Dali::DaliException e) {
72326       {
72327         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72328       };
72329     } catch (...) {
72330       {
72331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72332       };
72333     }
72334   }
72335
72336
72337   //argout typemap for const std::string&
72338
72339 }
72340
72341
72342 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
72343   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
72344   std::string *arg2 = 0 ;
72345   Dali::ImageDimensions arg3 ;
72346   Dali::ImageDimensions *argp3 ;
72347
72348   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72349   if (!jarg2) {
72350     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72351     return ;
72352   }
72353   std::string arg2_str(jarg2);
72354   arg2 = &arg2_str;
72355   argp3 = (Dali::ImageDimensions *)jarg3;
72356   if (!argp3) {
72357     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
72358     return ;
72359   }
72360   arg3 = *argp3;
72361   {
72362     try {
72363       (arg1)->SetImage((std::string const &)*arg2,arg3);
72364     } catch (std::out_of_range& e) {
72365       {
72366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72367       };
72368     } catch (std::exception& e) {
72369       {
72370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72371       };
72372     } catch (Dali::DaliException e) {
72373       {
72374         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72375       };
72376     } catch (...) {
72377       {
72378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72379       };
72380     }
72381   }
72382
72383
72384   //argout typemap for const std::string&
72385
72386 }
72387
72388 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_GetImage(void * jarg1) {
72389   void * jresult ;
72390   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
72391   Dali::Image result;
72392
72393   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72394   {
72395     try {
72396       result = ((Dali::Toolkit::ImageView const *)arg1)->GetImage();
72397     } catch (std::out_of_range& e) {
72398       {
72399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72400       };
72401     } catch (std::exception& e) {
72402       {
72403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72404       };
72405     } catch (Dali::DaliException e) {
72406       {
72407         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72408       };
72409     } catch (...) {
72410       {
72411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72412       };
72413     }
72414   }
72415
72416   jresult = new Dali::Image((const Dali::Image &)result);
72417   return jresult;
72418 }
72419
72420
72421 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_GEOMETRY_URL_get() {
72422   int jresult ;
72423   int result;
72424
72425   result = (int)Dali::Toolkit::Model3dView::Property::GEOMETRY_URL;
72426   jresult = (int)result;
72427   return jresult;
72428 }
72429
72430
72431 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_MATERIAL_URL_get() {
72432   int jresult ;
72433   int result;
72434
72435   result = (int)Dali::Toolkit::Model3dView::Property::MATERIAL_URL;
72436   jresult = (int)result;
72437   return jresult;
72438 }
72439
72440
72441 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_IMAGES_URL_get() {
72442   int jresult ;
72443   int result;
72444
72445   result = (int)Dali::Toolkit::Model3dView::Property::IMAGES_URL;
72446   jresult = (int)result;
72447   return jresult;
72448 }
72449
72450
72451 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_ILLUMINATION_TYPE_get() {
72452   int jresult ;
72453   int result;
72454
72455   result = (int)Dali::Toolkit::Model3dView::Property::ILLUMINATION_TYPE;
72456   jresult = (int)result;
72457   return jresult;
72458 }
72459
72460
72461 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE0_URL_get() {
72462   int jresult ;
72463   int result;
72464
72465   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE0_URL;
72466   jresult = (int)result;
72467   return jresult;
72468 }
72469
72470
72471 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE1_URL_get() {
72472   int jresult ;
72473   int result;
72474
72475   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE1_URL;
72476   jresult = (int)result;
72477   return jresult;
72478 }
72479
72480
72481 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE2_URL_get() {
72482   int jresult ;
72483   int result;
72484
72485   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE2_URL;
72486   jresult = (int)result;
72487   return jresult;
72488 }
72489
72490
72491 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_LIGHT_POSITION_get() {
72492   int jresult ;
72493   int result;
72494
72495   result = (int)Dali::Toolkit::Model3dView::Property::LIGHT_POSITION;
72496   jresult = (int)result;
72497   return jresult;
72498 }
72499
72500
72501 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView_Property() {
72502   void * jresult ;
72503   Dali::Toolkit::Model3dView::Property *result = 0 ;
72504
72505   {
72506     try {
72507       result = (Dali::Toolkit::Model3dView::Property *)new Dali::Toolkit::Model3dView::Property();
72508     } catch (std::out_of_range& e) {
72509       {
72510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72511       };
72512     } catch (std::exception& e) {
72513       {
72514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72515       };
72516     } catch (Dali::DaliException e) {
72517       {
72518         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72519       };
72520     } catch (...) {
72521       {
72522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72523       };
72524     }
72525   }
72526
72527   jresult = (void *)result;
72528   return jresult;
72529 }
72530
72531
72532 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView_Property(void * jarg1) {
72533   Dali::Toolkit::Model3dView::Property *arg1 = (Dali::Toolkit::Model3dView::Property *) 0 ;
72534
72535   arg1 = (Dali::Toolkit::Model3dView::Property *)jarg1;
72536   {
72537     try {
72538       delete arg1;
72539     } catch (std::out_of_range& e) {
72540       {
72541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72542       };
72543     } catch (std::exception& e) {
72544       {
72545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72546       };
72547     } catch (Dali::DaliException e) {
72548       {
72549         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72550       };
72551     } catch (...) {
72552       {
72553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72554       };
72555     }
72556   }
72557
72558 }
72559
72560
72561 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_0() {
72562   void * jresult ;
72563   Dali::Toolkit::Model3dView result;
72564
72565   {
72566     try {
72567       result = Dali::Toolkit::Model3dView::New();
72568     } catch (std::out_of_range& e) {
72569       {
72570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72571       };
72572     } catch (std::exception& e) {
72573       {
72574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72575       };
72576     } catch (Dali::DaliException e) {
72577       {
72578         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72579       };
72580     } catch (...) {
72581       {
72582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72583       };
72584     }
72585   }
72586
72587   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
72588   return jresult;
72589 }
72590
72591
72592 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_1(char * jarg1, char * jarg2, char * jarg3) {
72593   void * jresult ;
72594   std::string *arg1 = 0 ;
72595   std::string *arg2 = 0 ;
72596   std::string *arg3 = 0 ;
72597   Dali::Toolkit::Model3dView result;
72598
72599   if (!jarg1) {
72600     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72601     return 0;
72602   }
72603   std::string arg1_str(jarg1);
72604   arg1 = &arg1_str;
72605   if (!jarg2) {
72606     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72607     return 0;
72608   }
72609   std::string arg2_str(jarg2);
72610   arg2 = &arg2_str;
72611   if (!jarg3) {
72612     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72613     return 0;
72614   }
72615   std::string arg3_str(jarg3);
72616   arg3 = &arg3_str;
72617   {
72618     try {
72619       result = Dali::Toolkit::Model3dView::New((std::string const &)*arg1,(std::string const &)*arg2,(std::string const &)*arg3);
72620     } catch (std::out_of_range& e) {
72621       {
72622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72623       };
72624     } catch (std::exception& e) {
72625       {
72626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72627       };
72628     } catch (Dali::DaliException e) {
72629       {
72630         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72631       };
72632     } catch (...) {
72633       {
72634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72635       };
72636     }
72637   }
72638
72639   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
72640
72641   //argout typemap for const std::string&
72642
72643
72644   //argout typemap for const std::string&
72645
72646
72647   //argout typemap for const std::string&
72648
72649   return jresult;
72650 }
72651
72652
72653 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_0() {
72654   void * jresult ;
72655   Dali::Toolkit::Model3dView *result = 0 ;
72656
72657   {
72658     try {
72659       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView();
72660     } catch (std::out_of_range& e) {
72661       {
72662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72663       };
72664     } catch (std::exception& e) {
72665       {
72666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72667       };
72668     } catch (Dali::DaliException e) {
72669       {
72670         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72671       };
72672     } catch (...) {
72673       {
72674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72675       };
72676     }
72677   }
72678
72679   jresult = (void *)result;
72680   return jresult;
72681 }
72682
72683
72684 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView(void * jarg1) {
72685   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
72686
72687   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
72688   {
72689     try {
72690       delete arg1;
72691     } catch (std::out_of_range& e) {
72692       {
72693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72694       };
72695     } catch (std::exception& e) {
72696       {
72697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72698       };
72699     } catch (Dali::DaliException e) {
72700       {
72701         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72702       };
72703     } catch (...) {
72704       {
72705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72706       };
72707     }
72708   }
72709
72710 }
72711
72712
72713 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_1(void * jarg1) {
72714   void * jresult ;
72715   Dali::Toolkit::Model3dView *arg1 = 0 ;
72716   Dali::Toolkit::Model3dView *result = 0 ;
72717
72718   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
72719   if (!arg1) {
72720     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
72721     return 0;
72722   }
72723   {
72724     try {
72725       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView((Dali::Toolkit::Model3dView const &)*arg1);
72726     } catch (std::out_of_range& e) {
72727       {
72728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72729       };
72730     } catch (std::exception& e) {
72731       {
72732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72733       };
72734     } catch (Dali::DaliException e) {
72735       {
72736         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72737       };
72738     } catch (...) {
72739       {
72740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72741       };
72742     }
72743   }
72744
72745   jresult = (void *)result;
72746   return jresult;
72747 }
72748
72749
72750 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_Assign(void * jarg1, void * jarg2) {
72751   void * jresult ;
72752   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
72753   Dali::Toolkit::Model3dView *arg2 = 0 ;
72754   Dali::Toolkit::Model3dView *result = 0 ;
72755
72756   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
72757   arg2 = (Dali::Toolkit::Model3dView *)jarg2;
72758   if (!arg2) {
72759     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
72760     return 0;
72761   }
72762   {
72763     try {
72764       result = (Dali::Toolkit::Model3dView *) &(arg1)->operator =((Dali::Toolkit::Model3dView const &)*arg2);
72765     } catch (std::out_of_range& e) {
72766       {
72767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72768       };
72769     } catch (std::exception& e) {
72770       {
72771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72772       };
72773     } catch (Dali::DaliException e) {
72774       {
72775         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72776       };
72777     } catch (...) {
72778       {
72779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72780       };
72781     }
72782   }
72783
72784   jresult = (void *)result;
72785   return jresult;
72786 }
72787
72788
72789 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_DownCast(void * jarg1) {
72790   void * jresult ;
72791   Dali::BaseHandle arg1 ;
72792   Dali::BaseHandle *argp1 ;
72793   Dali::Toolkit::Model3dView result;
72794
72795   argp1 = (Dali::BaseHandle *)jarg1;
72796   if (!argp1) {
72797     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
72798     return 0;
72799   }
72800   arg1 = *argp1;
72801   {
72802     try {
72803       result = Dali::Toolkit::Model3dView::DownCast(arg1);
72804     } catch (std::out_of_range& e) {
72805       {
72806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72807       };
72808     } catch (std::exception& e) {
72809       {
72810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72811       };
72812     } catch (Dali::DaliException e) {
72813       {
72814         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72815       };
72816     } catch (...) {
72817       {
72818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72819       };
72820     }
72821   }
72822
72823   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
72824   return jresult;
72825 }
72826
72827
72828 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_DIRECTION_get() {
72829   int jresult ;
72830   int result;
72831
72832   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_DIRECTION;
72833   jresult = (int)result;
72834   return jresult;
72835 }
72836
72837
72838 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HEIGHT_POLICY_get() {
72839   int jresult ;
72840   int result;
72841
72842   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HEIGHT_POLICY;
72843   jresult = (int)result;
72844   return jresult;
72845 }
72846
72847
72848 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_FIXED_HEIGHT_get() {
72849   int jresult ;
72850   int result;
72851
72852   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_FIXED_HEIGHT;
72853   jresult = (int)result;
72854   return jresult;
72855 }
72856
72857
72858 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_SHOW_DURATION_get() {
72859   int jresult ;
72860   int result;
72861
72862   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_SHOW_DURATION;
72863   jresult = (int)result;
72864   return jresult;
72865 }
72866
72867
72868 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HIDE_DURATION_get() {
72869   int jresult ;
72870   int result;
72871
72872   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HIDE_DURATION;
72873   jresult = (int)result;
72874   return jresult;
72875 }
72876
72877
72878 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_POSITION_INTERVALS_get() {
72879   int jresult ;
72880   int result;
72881
72882   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_POSITION_INTERVALS;
72883   jresult = (int)result;
72884   return jresult;
72885 }
72886
72887
72888 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_MINIMUM_HEIGHT_get() {
72889   int jresult ;
72890   int result;
72891
72892   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_MINIMUM_HEIGHT;
72893   jresult = (int)result;
72894   return jresult;
72895 }
72896
72897
72898 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_START_PADDING_get() {
72899   int jresult ;
72900   int result;
72901
72902   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_START_PADDING;
72903   jresult = (int)result;
72904   return jresult;
72905 }
72906
72907
72908 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_END_PADDING_get() {
72909   int jresult ;
72910   int result;
72911
72912   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_END_PADDING;
72913   jresult = (int)result;
72914   return jresult;
72915 }
72916
72917
72918 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar_Property() {
72919   void * jresult ;
72920   Dali::Toolkit::ScrollBar::Property *result = 0 ;
72921
72922   {
72923     try {
72924       result = (Dali::Toolkit::ScrollBar::Property *)new Dali::Toolkit::ScrollBar::Property();
72925     } catch (std::out_of_range& e) {
72926       {
72927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72928       };
72929     } catch (std::exception& e) {
72930       {
72931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72932       };
72933     } catch (Dali::DaliException e) {
72934       {
72935         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72936       };
72937     } catch (...) {
72938       {
72939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72940       };
72941     }
72942   }
72943
72944   jresult = (void *)result;
72945   return jresult;
72946 }
72947
72948
72949 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar_Property(void * jarg1) {
72950   Dali::Toolkit::ScrollBar::Property *arg1 = (Dali::Toolkit::ScrollBar::Property *) 0 ;
72951
72952   arg1 = (Dali::Toolkit::ScrollBar::Property *)jarg1;
72953   {
72954     try {
72955       delete arg1;
72956     } catch (std::out_of_range& e) {
72957       {
72958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72959       };
72960     } catch (std::exception& e) {
72961       {
72962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72963       };
72964     } catch (Dali::DaliException e) {
72965       {
72966         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72967       };
72968     } catch (...) {
72969       {
72970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72971       };
72972     }
72973   }
72974
72975 }
72976
72977
72978 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_0() {
72979   void * jresult ;
72980   Dali::Toolkit::ScrollBar *result = 0 ;
72981
72982   {
72983     try {
72984       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar();
72985     } catch (std::out_of_range& e) {
72986       {
72987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72988       };
72989     } catch (std::exception& e) {
72990       {
72991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72992       };
72993     } catch (Dali::DaliException e) {
72994       {
72995         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72996       };
72997     } catch (...) {
72998       {
72999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73000       };
73001     }
73002   }
73003
73004   jresult = (void *)result;
73005   return jresult;
73006 }
73007
73008
73009 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_1(void * jarg1) {
73010   void * jresult ;
73011   Dali::Toolkit::ScrollBar *arg1 = 0 ;
73012   Dali::Toolkit::ScrollBar *result = 0 ;
73013
73014   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73015   if (!arg1) {
73016     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
73017     return 0;
73018   }
73019   {
73020     try {
73021       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar((Dali::Toolkit::ScrollBar const &)*arg1);
73022     } catch (std::out_of_range& e) {
73023       {
73024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73025       };
73026     } catch (std::exception& e) {
73027       {
73028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73029       };
73030     } catch (Dali::DaliException e) {
73031       {
73032         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73033       };
73034     } catch (...) {
73035       {
73036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73037       };
73038     }
73039   }
73040
73041   jresult = (void *)result;
73042   return jresult;
73043 }
73044
73045
73046 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_Assign(void * jarg1, void * jarg2) {
73047   void * jresult ;
73048   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73049   Dali::Toolkit::ScrollBar *arg2 = 0 ;
73050   Dali::Toolkit::ScrollBar *result = 0 ;
73051
73052   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73053   arg2 = (Dali::Toolkit::ScrollBar *)jarg2;
73054   if (!arg2) {
73055     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
73056     return 0;
73057   }
73058   {
73059     try {
73060       result = (Dali::Toolkit::ScrollBar *) &(arg1)->operator =((Dali::Toolkit::ScrollBar const &)*arg2);
73061     } catch (std::out_of_range& e) {
73062       {
73063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73064       };
73065     } catch (std::exception& e) {
73066       {
73067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73068       };
73069     } catch (Dali::DaliException e) {
73070       {
73071         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73072       };
73073     } catch (...) {
73074       {
73075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73076       };
73077     }
73078   }
73079
73080   jresult = (void *)result;
73081   return jresult;
73082 }
73083
73084
73085 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar(void * jarg1) {
73086   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73087
73088   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73089   {
73090     try {
73091       delete arg1;
73092     } catch (std::out_of_range& e) {
73093       {
73094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73095       };
73096     } catch (std::exception& e) {
73097       {
73098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73099       };
73100     } catch (Dali::DaliException e) {
73101       {
73102         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73103       };
73104     } catch (...) {
73105       {
73106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73107       };
73108     }
73109   }
73110
73111 }
73112
73113
73114 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_0(int jarg1) {
73115   void * jresult ;
73116   Dali::Toolkit::ScrollBar::Direction arg1 ;
73117   Dali::Toolkit::ScrollBar result;
73118
73119   arg1 = (Dali::Toolkit::ScrollBar::Direction)jarg1;
73120   {
73121     try {
73122       result = Dali::Toolkit::ScrollBar::New(arg1);
73123     } catch (std::out_of_range& e) {
73124       {
73125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73126       };
73127     } catch (std::exception& e) {
73128       {
73129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73130       };
73131     } catch (Dali::DaliException e) {
73132       {
73133         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73134       };
73135     } catch (...) {
73136       {
73137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73138       };
73139     }
73140   }
73141
73142   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
73143   return jresult;
73144 }
73145
73146
73147 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_1() {
73148   void * jresult ;
73149   Dali::Toolkit::ScrollBar result;
73150
73151   {
73152     try {
73153       result = Dali::Toolkit::ScrollBar::New();
73154     } catch (std::out_of_range& e) {
73155       {
73156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73157       };
73158     } catch (std::exception& e) {
73159       {
73160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73161       };
73162     } catch (Dali::DaliException e) {
73163       {
73164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73165       };
73166     } catch (...) {
73167       {
73168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73169       };
73170     }
73171   }
73172
73173   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
73174   return jresult;
73175 }
73176
73177
73178 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_DownCast(void * jarg1) {
73179   void * jresult ;
73180   Dali::BaseHandle arg1 ;
73181   Dali::BaseHandle *argp1 ;
73182   Dali::Toolkit::ScrollBar result;
73183
73184   argp1 = (Dali::BaseHandle *)jarg1;
73185   if (!argp1) {
73186     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
73187     return 0;
73188   }
73189   arg1 = *argp1;
73190   {
73191     try {
73192       result = Dali::Toolkit::ScrollBar::DownCast(arg1);
73193     } catch (std::out_of_range& e) {
73194       {
73195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73196       };
73197     } catch (std::exception& e) {
73198       {
73199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73200       };
73201     } catch (Dali::DaliException e) {
73202       {
73203         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73204       };
73205     } catch (...) {
73206       {
73207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73208       };
73209     }
73210   }
73211
73212   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
73213   return jresult;
73214 }
73215
73216
73217 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPropertySource(void * jarg1, void * jarg2, int jarg3, int jarg4, int jarg5, int jarg6) {
73218   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73219   Dali::Handle arg2 ;
73220   Dali::Property::Index arg3 ;
73221   Dali::Property::Index arg4 ;
73222   Dali::Property::Index arg5 ;
73223   Dali::Property::Index arg6 ;
73224   Dali::Handle *argp2 ;
73225
73226   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73227   argp2 = (Dali::Handle *)jarg2;
73228   if (!argp2) {
73229     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Handle", 0);
73230     return ;
73231   }
73232   arg2 = *argp2;
73233   arg3 = (Dali::Property::Index)jarg3;
73234   arg4 = (Dali::Property::Index)jarg4;
73235   arg5 = (Dali::Property::Index)jarg5;
73236   arg6 = (Dali::Property::Index)jarg6;
73237   {
73238     try {
73239       (arg1)->SetScrollPropertySource(arg2,arg3,arg4,arg5,arg6);
73240     } catch (std::out_of_range& e) {
73241       {
73242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73243       };
73244     } catch (std::exception& e) {
73245       {
73246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73247       };
73248     } catch (Dali::DaliException e) {
73249       {
73250         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73251       };
73252     } catch (...) {
73253       {
73254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73255       };
73256     }
73257   }
73258
73259 }
73260
73261
73262 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollIndicator(void * jarg1, void * jarg2) {
73263   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73264   Dali::Actor arg2 ;
73265   Dali::Actor *argp2 ;
73266
73267   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73268   argp2 = (Dali::Actor *)jarg2;
73269   if (!argp2) {
73270     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
73271     return ;
73272   }
73273   arg2 = *argp2;
73274   {
73275     try {
73276       (arg1)->SetScrollIndicator(arg2);
73277     } catch (std::out_of_range& e) {
73278       {
73279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73280       };
73281     } catch (std::exception& e) {
73282       {
73283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73284       };
73285     } catch (Dali::DaliException e) {
73286       {
73287         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73288       };
73289     } catch (...) {
73290       {
73291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73292       };
73293     }
73294   }
73295
73296 }
73297
73298
73299 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollIndicator(void * jarg1) {
73300   void * jresult ;
73301   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73302   Dali::Actor result;
73303
73304   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73305   {
73306     try {
73307       result = (arg1)->GetScrollIndicator();
73308     } catch (std::out_of_range& e) {
73309       {
73310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73311       };
73312     } catch (std::exception& e) {
73313       {
73314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73315       };
73316     } catch (Dali::DaliException e) {
73317       {
73318         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73319       };
73320     } catch (...) {
73321       {
73322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73323       };
73324     }
73325   }
73326
73327   jresult = new Dali::Actor((const Dali::Actor &)result);
73328   return jresult;
73329 }
73330
73331
73332 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPositionIntervals(void * jarg1, void * jarg2) {
73333   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73334   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg2 = 0 ;
73335
73336   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73337   arg2 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg2;
73338   if (!arg2) {
73339     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
73340     return ;
73341   }
73342   {
73343     try {
73344       (arg1)->SetScrollPositionIntervals((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg2);
73345     } catch (std::out_of_range& e) {
73346       {
73347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73348       };
73349     } catch (std::exception& e) {
73350       {
73351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73352       };
73353     } catch (Dali::DaliException e) {
73354       {
73355         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73356       };
73357     } catch (...) {
73358       {
73359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73360       };
73361     }
73362   }
73363
73364 }
73365
73366
73367 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollPositionIntervals(void * jarg1) {
73368   void * jresult ;
73369   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73370
73371   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73372   {
73373     try {
73374       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()));
73375     } catch (std::out_of_range& e) {
73376       {
73377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73378       };
73379     } catch (std::exception& e) {
73380       {
73381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73382       };
73383     } catch (...) {
73384       {
73385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73386       };
73387     }
73388   }
73389   return jresult;
73390 }
73391
73392
73393 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollDirection(void * jarg1, int jarg2) {
73394   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73395   Dali::Toolkit::ScrollBar::Direction arg2 ;
73396
73397   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73398   arg2 = (Dali::Toolkit::ScrollBar::Direction)jarg2;
73399   {
73400     try {
73401       (arg1)->SetScrollDirection(arg2);
73402     } catch (std::out_of_range& e) {
73403       {
73404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73405       };
73406     } catch (std::exception& e) {
73407       {
73408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73409       };
73410     } catch (Dali::DaliException e) {
73411       {
73412         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73413       };
73414     } catch (...) {
73415       {
73416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73417       };
73418     }
73419   }
73420
73421 }
73422
73423
73424 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollDirection(void * jarg1) {
73425   int jresult ;
73426   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73427   Dali::Toolkit::ScrollBar::Direction result;
73428
73429   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73430   {
73431     try {
73432       result = (Dali::Toolkit::ScrollBar::Direction)((Dali::Toolkit::ScrollBar const *)arg1)->GetScrollDirection();
73433     } catch (std::out_of_range& e) {
73434       {
73435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73436       };
73437     } catch (std::exception& e) {
73438       {
73439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73440       };
73441     } catch (Dali::DaliException e) {
73442       {
73443         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73444       };
73445     } catch (...) {
73446       {
73447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73448       };
73449     }
73450   }
73451
73452   jresult = (int)result;
73453   return jresult;
73454 }
73455
73456
73457 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHeightPolicy(void * jarg1, int jarg2) {
73458   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73459   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy arg2 ;
73460
73461   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73462   arg2 = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)jarg2;
73463   {
73464     try {
73465       (arg1)->SetIndicatorHeightPolicy(arg2);
73466     } catch (std::out_of_range& e) {
73467       {
73468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73469       };
73470     } catch (std::exception& e) {
73471       {
73472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73473       };
73474     } catch (Dali::DaliException e) {
73475       {
73476         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73477       };
73478     } catch (...) {
73479       {
73480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73481       };
73482     }
73483   }
73484
73485 }
73486
73487
73488 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHeightPolicy(void * jarg1) {
73489   int jresult ;
73490   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73491   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy result;
73492
73493   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73494   {
73495     try {
73496       result = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHeightPolicy();
73497     } catch (std::out_of_range& e) {
73498       {
73499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73500       };
73501     } catch (std::exception& e) {
73502       {
73503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73504       };
73505     } catch (Dali::DaliException e) {
73506       {
73507         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73508       };
73509     } catch (...) {
73510       {
73511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73512       };
73513     }
73514   }
73515
73516   jresult = (int)result;
73517   return jresult;
73518 }
73519
73520
73521 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorFixedHeight(void * jarg1, float jarg2) {
73522   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73523   float arg2 ;
73524
73525   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73526   arg2 = (float)jarg2;
73527   {
73528     try {
73529       (arg1)->SetIndicatorFixedHeight(arg2);
73530     } catch (std::out_of_range& e) {
73531       {
73532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73533       };
73534     } catch (std::exception& e) {
73535       {
73536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73537       };
73538     } catch (Dali::DaliException e) {
73539       {
73540         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73541       };
73542     } catch (...) {
73543       {
73544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73545       };
73546     }
73547   }
73548
73549 }
73550
73551
73552 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorFixedHeight(void * jarg1) {
73553   float jresult ;
73554   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73555   float result;
73556
73557   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73558   {
73559     try {
73560       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorFixedHeight();
73561     } catch (std::out_of_range& e) {
73562       {
73563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73564       };
73565     } catch (std::exception& e) {
73566       {
73567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73568       };
73569     } catch (Dali::DaliException e) {
73570       {
73571         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73572       };
73573     } catch (...) {
73574       {
73575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73576       };
73577     }
73578   }
73579
73580   jresult = result;
73581   return jresult;
73582 }
73583
73584
73585 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorShowDuration(void * jarg1, float jarg2) {
73586   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73587   float arg2 ;
73588
73589   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73590   arg2 = (float)jarg2;
73591   {
73592     try {
73593       (arg1)->SetIndicatorShowDuration(arg2);
73594     } catch (std::out_of_range& e) {
73595       {
73596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73597       };
73598     } catch (std::exception& e) {
73599       {
73600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73601       };
73602     } catch (Dali::DaliException e) {
73603       {
73604         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73605       };
73606     } catch (...) {
73607       {
73608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73609       };
73610     }
73611   }
73612
73613 }
73614
73615
73616 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorShowDuration(void * jarg1) {
73617   float jresult ;
73618   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73619   float result;
73620
73621   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73622   {
73623     try {
73624       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorShowDuration();
73625     } catch (std::out_of_range& e) {
73626       {
73627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73628       };
73629     } catch (std::exception& e) {
73630       {
73631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73632       };
73633     } catch (Dali::DaliException e) {
73634       {
73635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73636       };
73637     } catch (...) {
73638       {
73639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73640       };
73641     }
73642   }
73643
73644   jresult = result;
73645   return jresult;
73646 }
73647
73648
73649 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHideDuration(void * jarg1, float jarg2) {
73650   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73651   float arg2 ;
73652
73653   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73654   arg2 = (float)jarg2;
73655   {
73656     try {
73657       (arg1)->SetIndicatorHideDuration(arg2);
73658     } catch (std::out_of_range& e) {
73659       {
73660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73661       };
73662     } catch (std::exception& e) {
73663       {
73664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73665       };
73666     } catch (Dali::DaliException e) {
73667       {
73668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73669       };
73670     } catch (...) {
73671       {
73672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73673       };
73674     }
73675   }
73676
73677 }
73678
73679
73680 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHideDuration(void * jarg1) {
73681   float jresult ;
73682   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73683   float result;
73684
73685   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73686   {
73687     try {
73688       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHideDuration();
73689     } catch (std::out_of_range& e) {
73690       {
73691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73692       };
73693     } catch (std::exception& e) {
73694       {
73695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73696       };
73697     } catch (Dali::DaliException e) {
73698       {
73699         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73700       };
73701     } catch (...) {
73702       {
73703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73704       };
73705     }
73706   }
73707
73708   jresult = result;
73709   return jresult;
73710 }
73711
73712
73713 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_ShowIndicator(void * jarg1) {
73714   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73715
73716   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73717   {
73718     try {
73719       (arg1)->ShowIndicator();
73720     } catch (std::out_of_range& e) {
73721       {
73722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73723       };
73724     } catch (std::exception& e) {
73725       {
73726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73727       };
73728     } catch (Dali::DaliException e) {
73729       {
73730         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73731       };
73732     } catch (...) {
73733       {
73734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73735       };
73736     }
73737   }
73738
73739 }
73740
73741
73742 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_HideIndicator(void * jarg1) {
73743   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73744
73745   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73746   {
73747     try {
73748       (arg1)->HideIndicator();
73749     } catch (std::out_of_range& e) {
73750       {
73751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73752       };
73753     } catch (std::exception& e) {
73754       {
73755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73756       };
73757     } catch (Dali::DaliException e) {
73758       {
73759         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73760       };
73761     } catch (...) {
73762       {
73763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73764       };
73765     }
73766   }
73767
73768 }
73769
73770
73771 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_PanFinishedSignal(void * jarg1) {
73772   void * jresult ;
73773   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73774   Dali::Toolkit::ScrollBar::PanFinishedSignalType *result = 0 ;
73775
73776   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73777   {
73778     try {
73779       result = (Dali::Toolkit::ScrollBar::PanFinishedSignalType *) &(arg1)->PanFinishedSignal();
73780     } catch (std::out_of_range& e) {
73781       {
73782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73783       };
73784     } catch (std::exception& e) {
73785       {
73786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73787       };
73788     } catch (Dali::DaliException e) {
73789       {
73790         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73791       };
73792     } catch (...) {
73793       {
73794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73795       };
73796     }
73797   }
73798
73799   jresult = (void *)result;
73800   return jresult;
73801 }
73802
73803
73804 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_ScrollPositionIntervalReachedSignal(void * jarg1) {
73805   void * jresult ;
73806   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73807   Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *result = 0 ;
73808
73809   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73810   {
73811     try {
73812       result = (Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *) &(arg1)->ScrollPositionIntervalReachedSignal();
73813     } catch (std::out_of_range& e) {
73814       {
73815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73816       };
73817     } catch (std::exception& e) {
73818       {
73819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73820       };
73821     } catch (Dali::DaliException e) {
73822       {
73823         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73824       };
73825     } catch (...) {
73826       {
73827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73828       };
73829     }
73830   }
73831
73832   jresult = (void *)result;
73833   return jresult;
73834 }
73835
73836
73837 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_EFFECT_COLOR_get() {
73838   int jresult ;
73839   int result;
73840
73841   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_EFFECT_COLOR;
73842   jresult = (int)result;
73843   return jresult;
73844 }
73845
73846
73847 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ANIMATION_SPEED_get() {
73848   int jresult ;
73849   int result;
73850
73851   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ANIMATION_SPEED;
73852   jresult = (int)result;
73853   return jresult;
73854 }
73855
73856
73857 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ENABLED_get() {
73858   int jresult ;
73859   int result;
73860
73861   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ENABLED;
73862   jresult = (int)result;
73863   return jresult;
73864 }
73865
73866
73867 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_SIZE_get() {
73868   int jresult ;
73869   int result;
73870
73871   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_SIZE;
73872   jresult = (int)result;
73873   return jresult;
73874 }
73875
73876
73877 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_TO_ALPHA_FUNCTION_get() {
73878   int jresult ;
73879   int result;
73880
73881   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_TO_ALPHA_FUNCTION;
73882   jresult = (int)result;
73883   return jresult;
73884 }
73885
73886
73887 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_RELATIVE_POSITION_get() {
73888   int jresult ;
73889   int result;
73890
73891   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_RELATIVE_POSITION;
73892   jresult = (int)result;
73893   return jresult;
73894 }
73895
73896
73897 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_get() {
73898   int jresult ;
73899   int result;
73900
73901   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN;
73902   jresult = (int)result;
73903   return jresult;
73904 }
73905
73906
73907 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_X_get() {
73908   int jresult ;
73909   int result;
73910
73911   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_X;
73912   jresult = (int)result;
73913   return jresult;
73914 }
73915
73916
73917 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_Y_get() {
73918   int jresult ;
73919   int result;
73920
73921   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_Y;
73922   jresult = (int)result;
73923   return jresult;
73924 }
73925
73926
73927 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_get() {
73928   int jresult ;
73929   int result;
73930
73931   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX;
73932   jresult = (int)result;
73933   return jresult;
73934 }
73935
73936
73937 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_X_get() {
73938   int jresult ;
73939   int result;
73940
73941   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_X;
73942   jresult = (int)result;
73943   return jresult;
73944 }
73945
73946
73947 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_Y_get() {
73948   int jresult ;
73949   int result;
73950
73951   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_Y;
73952   jresult = (int)result;
73953   return jresult;
73954 }
73955
73956
73957 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_VERTICAL_get() {
73958   int jresult ;
73959   int result;
73960
73961   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_VERTICAL;
73962   jresult = (int)result;
73963   return jresult;
73964 }
73965
73966
73967 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_HORIZONTAL_get() {
73968   int jresult ;
73969   int result;
73970
73971   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_HORIZONTAL;
73972   jresult = (int)result;
73973   return jresult;
73974 }
73975
73976
73977 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable_Property() {
73978   void * jresult ;
73979   Dali::Toolkit::Scrollable::Property *result = 0 ;
73980
73981   {
73982     try {
73983       result = (Dali::Toolkit::Scrollable::Property *)new Dali::Toolkit::Scrollable::Property();
73984     } catch (std::out_of_range& e) {
73985       {
73986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73987       };
73988     } catch (std::exception& e) {
73989       {
73990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73991       };
73992     } catch (Dali::DaliException e) {
73993       {
73994         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73995       };
73996     } catch (...) {
73997       {
73998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73999       };
74000     }
74001   }
74002
74003   jresult = (void *)result;
74004   return jresult;
74005 }
74006
74007
74008 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable_Property(void * jarg1) {
74009   Dali::Toolkit::Scrollable::Property *arg1 = (Dali::Toolkit::Scrollable::Property *) 0 ;
74010
74011   arg1 = (Dali::Toolkit::Scrollable::Property *)jarg1;
74012   {
74013     try {
74014       delete arg1;
74015     } catch (std::out_of_range& e) {
74016       {
74017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74018       };
74019     } catch (std::exception& e) {
74020       {
74021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74022       };
74023     } catch (Dali::DaliException e) {
74024       {
74025         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74026       };
74027     } catch (...) {
74028       {
74029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74030       };
74031     }
74032   }
74033
74034 }
74035
74036
74037 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_0() {
74038   void * jresult ;
74039   Dali::Toolkit::Scrollable *result = 0 ;
74040
74041   {
74042     try {
74043       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable();
74044     } catch (std::out_of_range& e) {
74045       {
74046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74047       };
74048     } catch (std::exception& e) {
74049       {
74050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74051       };
74052     } catch (Dali::DaliException e) {
74053       {
74054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74055       };
74056     } catch (...) {
74057       {
74058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74059       };
74060     }
74061   }
74062
74063   jresult = (void *)result;
74064   return jresult;
74065 }
74066
74067
74068 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_1(void * jarg1) {
74069   void * jresult ;
74070   Dali::Toolkit::Scrollable *arg1 = 0 ;
74071   Dali::Toolkit::Scrollable *result = 0 ;
74072
74073   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74074   if (!arg1) {
74075     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
74076     return 0;
74077   }
74078   {
74079     try {
74080       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable((Dali::Toolkit::Scrollable const &)*arg1);
74081     } catch (std::out_of_range& e) {
74082       {
74083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74084       };
74085     } catch (std::exception& e) {
74086       {
74087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74088       };
74089     } catch (Dali::DaliException e) {
74090       {
74091         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74092       };
74093     } catch (...) {
74094       {
74095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74096       };
74097     }
74098   }
74099
74100   jresult = (void *)result;
74101   return jresult;
74102 }
74103
74104
74105 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_Assign(void * jarg1, void * jarg2) {
74106   void * jresult ;
74107   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74108   Dali::Toolkit::Scrollable *arg2 = 0 ;
74109   Dali::Toolkit::Scrollable *result = 0 ;
74110
74111   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74112   arg2 = (Dali::Toolkit::Scrollable *)jarg2;
74113   if (!arg2) {
74114     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
74115     return 0;
74116   }
74117   {
74118     try {
74119       result = (Dali::Toolkit::Scrollable *) &(arg1)->operator =((Dali::Toolkit::Scrollable const &)*arg2);
74120     } catch (std::out_of_range& e) {
74121       {
74122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74123       };
74124     } catch (std::exception& e) {
74125       {
74126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74127       };
74128     } catch (Dali::DaliException e) {
74129       {
74130         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74131       };
74132     } catch (...) {
74133       {
74134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74135       };
74136     }
74137   }
74138
74139   jresult = (void *)result;
74140   return jresult;
74141 }
74142
74143
74144 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable(void * jarg1) {
74145   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74146
74147   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74148   {
74149     try {
74150       delete arg1;
74151     } catch (std::out_of_range& e) {
74152       {
74153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74154       };
74155     } catch (std::exception& e) {
74156       {
74157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74158       };
74159     } catch (Dali::DaliException e) {
74160       {
74161         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74162       };
74163     } catch (...) {
74164       {
74165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74166       };
74167     }
74168   }
74169
74170 }
74171
74172
74173 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_DownCast(void * jarg1) {
74174   void * jresult ;
74175   Dali::BaseHandle arg1 ;
74176   Dali::BaseHandle *argp1 ;
74177   Dali::Toolkit::Scrollable result;
74178
74179   argp1 = (Dali::BaseHandle *)jarg1;
74180   if (!argp1) {
74181     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
74182     return 0;
74183   }
74184   arg1 = *argp1;
74185   {
74186     try {
74187       result = Dali::Toolkit::Scrollable::DownCast(arg1);
74188     } catch (std::out_of_range& e) {
74189       {
74190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74191       };
74192     } catch (std::exception& e) {
74193       {
74194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74195       };
74196     } catch (Dali::DaliException e) {
74197       {
74198         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74199       };
74200     } catch (...) {
74201       {
74202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74203       };
74204     }
74205   }
74206
74207   jresult = new Dali::Toolkit::Scrollable((const Dali::Toolkit::Scrollable &)result);
74208   return jresult;
74209 }
74210
74211
74212 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Scrollable_IsOvershootEnabled(void * jarg1) {
74213   unsigned int jresult ;
74214   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74215   bool result;
74216
74217   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74218   {
74219     try {
74220       result = (bool)((Dali::Toolkit::Scrollable const *)arg1)->IsOvershootEnabled();
74221     } catch (std::out_of_range& e) {
74222       {
74223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74224       };
74225     } catch (std::exception& e) {
74226       {
74227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74228       };
74229     } catch (Dali::DaliException e) {
74230       {
74231         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74232       };
74233     } catch (...) {
74234       {
74235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74236       };
74237     }
74238   }
74239
74240   jresult = result;
74241   return jresult;
74242 }
74243
74244
74245 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEnabled(void * jarg1, unsigned int jarg2) {
74246   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74247   bool arg2 ;
74248
74249   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74250   arg2 = jarg2 ? true : false;
74251   {
74252     try {
74253       (arg1)->SetOvershootEnabled(arg2);
74254     } catch (std::out_of_range& e) {
74255       {
74256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74257       };
74258     } catch (std::exception& e) {
74259       {
74260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74261       };
74262     } catch (Dali::DaliException e) {
74263       {
74264         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74265       };
74266     } catch (...) {
74267       {
74268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74269       };
74270     }
74271   }
74272
74273 }
74274
74275
74276 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEffectColor(void * jarg1, void * jarg2) {
74277   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74278   Dali::Vector4 *arg2 = 0 ;
74279
74280   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74281   arg2 = (Dali::Vector4 *)jarg2;
74282   if (!arg2) {
74283     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
74284     return ;
74285   }
74286   {
74287     try {
74288       (arg1)->SetOvershootEffectColor((Dali::Vector4 const &)*arg2);
74289     } catch (std::out_of_range& e) {
74290       {
74291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74292       };
74293     } catch (std::exception& e) {
74294       {
74295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74296       };
74297     } catch (Dali::DaliException e) {
74298       {
74299         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74300       };
74301     } catch (...) {
74302       {
74303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74304       };
74305     }
74306   }
74307
74308 }
74309
74310
74311 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootEffectColor(void * jarg1) {
74312   void * jresult ;
74313   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74314   Dali::Vector4 result;
74315
74316   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74317   {
74318     try {
74319       result = ((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootEffectColor();
74320     } catch (std::out_of_range& e) {
74321       {
74322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74323       };
74324     } catch (std::exception& e) {
74325       {
74326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74327       };
74328     } catch (Dali::DaliException e) {
74329       {
74330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74331       };
74332     } catch (...) {
74333       {
74334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74335       };
74336     }
74337   }
74338
74339   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
74340   return jresult;
74341 }
74342
74343
74344 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootAnimationSpeed(void * jarg1, float jarg2) {
74345   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74346   float arg2 ;
74347
74348   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74349   arg2 = (float)jarg2;
74350   {
74351     try {
74352       (arg1)->SetOvershootAnimationSpeed(arg2);
74353     } catch (std::out_of_range& e) {
74354       {
74355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74356       };
74357     } catch (std::exception& e) {
74358       {
74359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74360       };
74361     } catch (Dali::DaliException e) {
74362       {
74363         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74364       };
74365     } catch (...) {
74366       {
74367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74368       };
74369     }
74370   }
74371
74372 }
74373
74374
74375 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootAnimationSpeed(void * jarg1) {
74376   float jresult ;
74377   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74378   float result;
74379
74380   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74381   {
74382     try {
74383       result = (float)((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootAnimationSpeed();
74384     } catch (std::out_of_range& e) {
74385       {
74386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74387       };
74388     } catch (std::exception& e) {
74389       {
74390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74391       };
74392     } catch (Dali::DaliException e) {
74393       {
74394         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74395       };
74396     } catch (...) {
74397       {
74398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74399       };
74400     }
74401   }
74402
74403   jresult = result;
74404   return jresult;
74405 }
74406
74407
74408 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollStartedSignal(void * jarg1) {
74409   void * jresult ;
74410   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74411   Dali::Toolkit::Scrollable::ScrollStartedSignalType *result = 0 ;
74412
74413   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74414   {
74415     try {
74416       result = (Dali::Toolkit::Scrollable::ScrollStartedSignalType *) &(arg1)->ScrollStartedSignal();
74417     } catch (std::out_of_range& e) {
74418       {
74419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74420       };
74421     } catch (std::exception& e) {
74422       {
74423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74424       };
74425     } catch (Dali::DaliException e) {
74426       {
74427         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74428       };
74429     } catch (...) {
74430       {
74431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74432       };
74433     }
74434   }
74435
74436   jresult = (void *)result;
74437   return jresult;
74438 }
74439
74440
74441 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollUpdatedSignal(void * jarg1) {
74442   void * jresult ;
74443   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74444   Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *result = 0 ;
74445
74446   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74447   {
74448     try {
74449       result = (Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *) &(arg1)->ScrollUpdatedSignal();
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 void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollCompletedSignal(void * jarg1) {
74475   void * jresult ;
74476   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74477   Dali::Toolkit::Scrollable::ScrollCompletedSignalType *result = 0 ;
74478
74479   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74480   {
74481     try {
74482       result = (Dali::Toolkit::Scrollable::ScrollCompletedSignalType *) &(arg1)->ScrollCompletedSignal();
74483     } catch (std::out_of_range& e) {
74484       {
74485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74486       };
74487     } catch (std::exception& e) {
74488       {
74489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74490       };
74491     } catch (Dali::DaliException e) {
74492       {
74493         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74494       };
74495     } catch (...) {
74496       {
74497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74498       };
74499     }
74500   }
74501
74502   jresult = (void *)result;
74503   return jresult;
74504 }
74505
74506
74507 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsVertical(int jarg1) {
74508   unsigned int jresult ;
74509   Dali::Toolkit::ControlOrientation::Type arg1 ;
74510   bool result;
74511
74512   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
74513   {
74514     try {
74515       result = (bool)Dali::Toolkit::IsVertical(arg1);
74516     } catch (std::out_of_range& e) {
74517       {
74518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74519       };
74520     } catch (std::exception& e) {
74521       {
74522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74523       };
74524     } catch (Dali::DaliException e) {
74525       {
74526         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74527       };
74528     } catch (...) {
74529       {
74530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74531       };
74532     }
74533   }
74534
74535   jresult = result;
74536   return jresult;
74537 }
74538
74539
74540 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsHorizontal(int jarg1) {
74541   unsigned int jresult ;
74542   Dali::Toolkit::ControlOrientation::Type arg1 ;
74543   bool result;
74544
74545   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
74546   {
74547     try {
74548       result = (bool)Dali::Toolkit::IsHorizontal(arg1);
74549     } catch (std::out_of_range& e) {
74550       {
74551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74552       };
74553     } catch (std::exception& e) {
74554       {
74555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74556       };
74557     } catch (Dali::DaliException e) {
74558       {
74559         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74560       };
74561     } catch (...) {
74562       {
74563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74564       };
74565     }
74566   }
74567
74568   jresult = result;
74569   return jresult;
74570 }
74571
74572
74573 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_0(unsigned int jarg1, unsigned int jarg2) {
74574   void * jresult ;
74575   unsigned int arg1 ;
74576   unsigned int arg2 ;
74577   Dali::Toolkit::ItemRange *result = 0 ;
74578
74579   arg1 = (unsigned int)jarg1;
74580   arg2 = (unsigned int)jarg2;
74581   {
74582     try {
74583       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange(arg1,arg2);
74584     } catch (std::out_of_range& e) {
74585       {
74586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74587       };
74588     } catch (std::exception& e) {
74589       {
74590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74591       };
74592     } catch (Dali::DaliException e) {
74593       {
74594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74595       };
74596     } catch (...) {
74597       {
74598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74599       };
74600     }
74601   }
74602
74603   jresult = (void *)result;
74604   return jresult;
74605 }
74606
74607
74608 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_1(void * jarg1) {
74609   void * jresult ;
74610   Dali::Toolkit::ItemRange *arg1 = 0 ;
74611   Dali::Toolkit::ItemRange *result = 0 ;
74612
74613   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74614   if (!arg1) {
74615     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
74616     return 0;
74617   }
74618   {
74619     try {
74620       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange((Dali::Toolkit::ItemRange const &)*arg1);
74621     } catch (std::out_of_range& e) {
74622       {
74623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74624       };
74625     } catch (std::exception& e) {
74626       {
74627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74628       };
74629     } catch (Dali::DaliException e) {
74630       {
74631         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74632       };
74633     } catch (...) {
74634       {
74635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74636       };
74637     }
74638   }
74639
74640   jresult = (void *)result;
74641   return jresult;
74642 }
74643
74644
74645 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Assign(void * jarg1, void * jarg2) {
74646   void * jresult ;
74647   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74648   Dali::Toolkit::ItemRange *arg2 = 0 ;
74649   Dali::Toolkit::ItemRange *result = 0 ;
74650
74651   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74652   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
74653   if (!arg2) {
74654     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
74655     return 0;
74656   }
74657   {
74658     try {
74659       result = (Dali::Toolkit::ItemRange *) &(arg1)->operator =((Dali::Toolkit::ItemRange const &)*arg2);
74660     } catch (std::out_of_range& e) {
74661       {
74662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74663       };
74664     } catch (std::exception& e) {
74665       {
74666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74667       };
74668     } catch (Dali::DaliException e) {
74669       {
74670         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74671       };
74672     } catch (...) {
74673       {
74674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74675       };
74676     }
74677   }
74678
74679   jresult = (void *)result;
74680   return jresult;
74681 }
74682
74683
74684 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_Within(void * jarg1, unsigned int jarg2) {
74685   unsigned int jresult ;
74686   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74687   unsigned int arg2 ;
74688   bool result;
74689
74690   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74691   arg2 = (unsigned int)jarg2;
74692   {
74693     try {
74694       result = (bool)(arg1)->Within(arg2);
74695     } catch (std::out_of_range& e) {
74696       {
74697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74698       };
74699     } catch (std::exception& e) {
74700       {
74701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74702       };
74703     } catch (Dali::DaliException e) {
74704       {
74705         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74706       };
74707     } catch (...) {
74708       {
74709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74710       };
74711     }
74712   }
74713
74714   jresult = result;
74715   return jresult;
74716 }
74717
74718
74719 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Intersection(void * jarg1, void * jarg2) {
74720   void * jresult ;
74721   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74722   Dali::Toolkit::ItemRange *arg2 = 0 ;
74723   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
74724
74725   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74726   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
74727   if (!arg2) {
74728     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
74729     return 0;
74730   }
74731   {
74732     try {
74733       result = (arg1)->Intersection((Dali::Toolkit::ItemRange const &)*arg2);
74734     } catch (std::out_of_range& e) {
74735       {
74736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74737       };
74738     } catch (std::exception& e) {
74739       {
74740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74741       };
74742     } catch (Dali::DaliException e) {
74743       {
74744         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74745       };
74746     } catch (...) {
74747       {
74748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74749       };
74750     }
74751   }
74752
74753   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
74754   return jresult;
74755 }
74756
74757
74758 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_begin_set(void * jarg1, unsigned int jarg2) {
74759   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74760   unsigned int arg2 ;
74761
74762   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74763   arg2 = (unsigned int)jarg2;
74764   if (arg1) (arg1)->begin = arg2;
74765 }
74766
74767
74768 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_begin_get(void * jarg1) {
74769   unsigned int jresult ;
74770   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74771   unsigned int result;
74772
74773   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74774   result = (unsigned int) ((arg1)->begin);
74775   jresult = result;
74776   return jresult;
74777 }
74778
74779
74780 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_end_set(void * jarg1, unsigned int jarg2) {
74781   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74782   unsigned int arg2 ;
74783
74784   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74785   arg2 = (unsigned int)jarg2;
74786   if (arg1) (arg1)->end = arg2;
74787 }
74788
74789
74790 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_end_get(void * jarg1) {
74791   unsigned int jresult ;
74792   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74793   unsigned int result;
74794
74795   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74796   result = (unsigned int) ((arg1)->end);
74797   jresult = result;
74798   return jresult;
74799 }
74800
74801
74802 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemRange(void * jarg1) {
74803   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74804
74805   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74806   {
74807     try {
74808       delete arg1;
74809     } catch (std::out_of_range& e) {
74810       {
74811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74812       };
74813     } catch (std::exception& e) {
74814       {
74815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74816       };
74817     } catch (Dali::DaliException e) {
74818       {
74819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74820       };
74821     } catch (...) {
74822       {
74823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74824       };
74825     }
74826   }
74827
74828 }
74829
74830
74831 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemLayout(void * jarg1) {
74832   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74833
74834   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74835   {
74836     try {
74837       delete arg1;
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 void SWIGSTDCALL CSharp_Dali_ItemLayout_SetOrientation(void * jarg1, int jarg2) {
74861   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74862   Dali::Toolkit::ControlOrientation::Type arg2 ;
74863
74864   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74865   arg2 = (Dali::Toolkit::ControlOrientation::Type)jarg2;
74866   {
74867     try {
74868       (arg1)->SetOrientation(arg2);
74869     } catch (std::out_of_range& e) {
74870       {
74871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74872       };
74873     } catch (std::exception& e) {
74874       {
74875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74876       };
74877     } catch (Dali::DaliException e) {
74878       {
74879         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74880       };
74881     } catch (...) {
74882       {
74883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74884       };
74885     }
74886   }
74887
74888 }
74889
74890
74891 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetOrientation(void * jarg1) {
74892   int jresult ;
74893   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74894   Dali::Toolkit::ControlOrientation::Type result;
74895
74896   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74897   {
74898     try {
74899       result = (Dali::Toolkit::ControlOrientation::Type)((Dali::Toolkit::ItemLayout const *)arg1)->GetOrientation();
74900     } catch (std::out_of_range& e) {
74901       {
74902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74903       };
74904     } catch (std::exception& e) {
74905       {
74906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74907       };
74908     } catch (Dali::DaliException e) {
74909       {
74910         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74911       };
74912     } catch (...) {
74913       {
74914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74915       };
74916     }
74917   }
74918
74919   jresult = (int)result;
74920   return jresult;
74921 }
74922
74923
74924 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetLayoutProperties(void * jarg1, void * jarg2) {
74925   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74926   Dali::Property::Map *arg2 = 0 ;
74927
74928   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74929   arg2 = (Dali::Property::Map *)jarg2;
74930   if (!arg2) {
74931     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
74932     return ;
74933   }
74934   {
74935     try {
74936       (arg1)->SetLayoutProperties((Dali::Property::Map const &)*arg2);
74937     } catch (std::out_of_range& e) {
74938       {
74939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74940       };
74941     } catch (std::exception& e) {
74942       {
74943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74944       };
74945     } catch (Dali::DaliException e) {
74946       {
74947         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74948       };
74949     } catch (...) {
74950       {
74951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74952       };
74953     }
74954   }
74955
74956 }
74957
74958
74959 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetLayoutProperties(void * jarg1) {
74960   void * jresult ;
74961   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74962   Dali::Property::Map result;
74963
74964   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74965   {
74966     try {
74967       result = (arg1)->GetLayoutProperties();
74968     } catch (std::out_of_range& e) {
74969       {
74970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74971       };
74972     } catch (std::exception& e) {
74973       {
74974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74975       };
74976     } catch (Dali::DaliException e) {
74977       {
74978         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74979       };
74980     } catch (...) {
74981       {
74982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74983       };
74984     }
74985   }
74986
74987   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
74988   return jresult;
74989 }
74990
74991
74992 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
74993   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74994   unsigned int arg2 ;
74995   Dali::Vector3 *arg3 = 0 ;
74996   Dali::Vector3 *arg4 = 0 ;
74997
74998   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74999   arg2 = (unsigned int)jarg2;
75000   arg3 = (Dali::Vector3 *)jarg3;
75001   if (!arg3) {
75002     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
75003     return ;
75004   }
75005   arg4 = (Dali::Vector3 *)jarg4;
75006   if (!arg4) {
75007     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
75008     return ;
75009   }
75010   {
75011     try {
75012       ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
75013     } catch (std::out_of_range& e) {
75014       {
75015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75016       };
75017     } catch (std::exception& e) {
75018       {
75019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75020       };
75021     } catch (Dali::DaliException e) {
75022       {
75023         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75024       };
75025     } catch (...) {
75026       {
75027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75028       };
75029     }
75030   }
75031
75032 }
75033
75034
75035 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetItemSize(void * jarg1, void * jarg2) {
75036   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75037   Dali::Vector3 *arg2 = 0 ;
75038
75039   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75040   arg2 = (Dali::Vector3 *)jarg2;
75041   if (!arg2) {
75042     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
75043     return ;
75044   }
75045   {
75046     try {
75047       (arg1)->SetItemSize((Dali::Vector3 const &)*arg2);
75048     } catch (std::out_of_range& e) {
75049       {
75050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75051       };
75052     } catch (std::exception& e) {
75053       {
75054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75055       };
75056     } catch (Dali::DaliException e) {
75057       {
75058         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75059       };
75060     } catch (...) {
75061       {
75062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75063       };
75064     }
75065   }
75066
75067 }
75068
75069
75070 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMinimumLayoutPosition(void * jarg1, unsigned int jarg2, void * jarg3) {
75071   float jresult ;
75072   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75073   unsigned int arg2 ;
75074   Dali::Vector3 arg3 ;
75075   Dali::Vector3 *argp3 ;
75076   float result;
75077
75078   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75079   arg2 = (unsigned int)jarg2;
75080   argp3 = (Dali::Vector3 *)jarg3;
75081   if (!argp3) {
75082     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
75083     return 0;
75084   }
75085   arg3 = *argp3;
75086   {
75087     try {
75088       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMinimumLayoutPosition(arg2,arg3);
75089     } catch (std::out_of_range& e) {
75090       {
75091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75092       };
75093     } catch (std::exception& e) {
75094       {
75095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75096       };
75097     } catch (Dali::DaliException e) {
75098       {
75099         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75100       };
75101     } catch (...) {
75102       {
75103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75104       };
75105     }
75106   }
75107
75108   jresult = result;
75109   return jresult;
75110 }
75111
75112
75113 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestAnchorPosition(void * jarg1, float jarg2) {
75114   float jresult ;
75115   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75116   float arg2 ;
75117   float result;
75118
75119   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75120   arg2 = (float)jarg2;
75121   {
75122     try {
75123       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetClosestAnchorPosition(arg2);
75124     } catch (std::out_of_range& e) {
75125       {
75126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75127       };
75128     } catch (std::exception& e) {
75129       {
75130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75131       };
75132     } catch (Dali::DaliException e) {
75133       {
75134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75135       };
75136     } catch (...) {
75137       {
75138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75139       };
75140     }
75141   }
75142
75143   jresult = result;
75144   return jresult;
75145 }
75146
75147
75148 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemScrollToPosition(void * jarg1, unsigned int jarg2) {
75149   float jresult ;
75150   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75151   unsigned int arg2 ;
75152   float result;
75153
75154   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75155   arg2 = (unsigned int)jarg2;
75156   {
75157     try {
75158       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemScrollToPosition(arg2);
75159     } catch (std::out_of_range& e) {
75160       {
75161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75162       };
75163     } catch (std::exception& e) {
75164       {
75165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75166       };
75167     } catch (Dali::DaliException e) {
75168       {
75169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75170       };
75171     } catch (...) {
75172       {
75173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75174       };
75175     }
75176   }
75177
75178   jresult = result;
75179   return jresult;
75180 }
75181
75182
75183 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemsWithinArea(void * jarg1, float jarg2, void * jarg3) {
75184   void * jresult ;
75185   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75186   float arg2 ;
75187   Dali::Vector3 arg3 ;
75188   Dali::Vector3 *argp3 ;
75189   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
75190
75191   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75192   arg2 = (float)jarg2;
75193   argp3 = (Dali::Vector3 *)jarg3;
75194   if (!argp3) {
75195     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
75196     return 0;
75197   }
75198   arg3 = *argp3;
75199   {
75200     try {
75201       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemsWithinArea(arg2,arg3);
75202     } catch (std::out_of_range& e) {
75203       {
75204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75205       };
75206     } catch (std::exception& e) {
75207       {
75208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75209       };
75210     } catch (Dali::DaliException e) {
75211       {
75212         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75213       };
75214     } catch (...) {
75215       {
75216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75217       };
75218     }
75219   }
75220
75221   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
75222   return jresult;
75223 }
75224
75225
75226 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestOnScreenLayoutPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
75227   float jresult ;
75228   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75229   int arg2 ;
75230   float arg3 ;
75231   Dali::Vector3 *arg4 = 0 ;
75232   float result;
75233
75234   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75235   arg2 = (int)jarg2;
75236   arg3 = (float)jarg3;
75237   arg4 = (Dali::Vector3 *)jarg4;
75238   if (!arg4) {
75239     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
75240     return 0;
75241   }
75242   {
75243     try {
75244       result = (float)(arg1)->GetClosestOnScreenLayoutPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
75245     } catch (std::out_of_range& e) {
75246       {
75247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75248       };
75249     } catch (std::exception& e) {
75250       {
75251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75252       };
75253     } catch (Dali::DaliException e) {
75254       {
75255         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75256       };
75257     } catch (...) {
75258       {
75259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75260       };
75261     }
75262   }
75263
75264   jresult = result;
75265   return jresult;
75266 }
75267
75268
75269 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemLayout_GetReserveItemCount(void * jarg1, void * jarg2) {
75270   unsigned int jresult ;
75271   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75272   Dali::Vector3 arg2 ;
75273   Dali::Vector3 *argp2 ;
75274   unsigned int result;
75275
75276   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75277   argp2 = (Dali::Vector3 *)jarg2;
75278   if (!argp2) {
75279     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
75280     return 0;
75281   }
75282   arg2 = *argp2;
75283   {
75284     try {
75285       result = (unsigned int)((Dali::Toolkit::ItemLayout const *)arg1)->GetReserveItemCount(arg2);
75286     } catch (std::out_of_range& e) {
75287       {
75288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75289       };
75290     } catch (std::exception& e) {
75291       {
75292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75293       };
75294     } catch (Dali::DaliException e) {
75295       {
75296         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75297       };
75298     } catch (...) {
75299       {
75300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75301       };
75302     }
75303   }
75304
75305   jresult = result;
75306   return jresult;
75307 }
75308
75309
75310 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetDefaultItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
75311   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75312   unsigned int arg2 ;
75313   Dali::Vector3 *arg3 = 0 ;
75314   Dali::Vector3 *arg4 = 0 ;
75315
75316   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75317   arg2 = (unsigned int)jarg2;
75318   arg3 = (Dali::Vector3 *)jarg3;
75319   if (!arg3) {
75320     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
75321     return ;
75322   }
75323   arg4 = (Dali::Vector3 *)jarg4;
75324   if (!arg4) {
75325     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
75326     return ;
75327   }
75328   {
75329     try {
75330       ((Dali::Toolkit::ItemLayout const *)arg1)->GetDefaultItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
75331     } catch (std::out_of_range& e) {
75332       {
75333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75334       };
75335     } catch (std::exception& e) {
75336       {
75337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75338       };
75339     } catch (Dali::DaliException e) {
75340       {
75341         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75342       };
75343     } catch (...) {
75344       {
75345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75346       };
75347     }
75348   }
75349
75350 }
75351
75352
75353 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollDirection(void * jarg1) {
75354   void * jresult ;
75355   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75356   Dali::Degree result;
75357
75358   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75359   {
75360     try {
75361       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollDirection();
75362     } catch (std::out_of_range& e) {
75363       {
75364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75365       };
75366     } catch (std::exception& e) {
75367       {
75368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75369       };
75370     } catch (Dali::DaliException e) {
75371       {
75372         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75373       };
75374     } catch (...) {
75375       {
75376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75377       };
75378     }
75379   }
75380
75381   jresult = new Dali::Degree((const Dali::Degree &)result);
75382   return jresult;
75383 }
75384
75385
75386 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollSpeedFactor(void * jarg1) {
75387   float jresult ;
75388   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75389   float result;
75390
75391   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75392   {
75393     try {
75394       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollSpeedFactor();
75395     } catch (std::out_of_range& e) {
75396       {
75397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75398       };
75399     } catch (std::exception& e) {
75400       {
75401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75402       };
75403     } catch (Dali::DaliException e) {
75404       {
75405         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75406       };
75407     } catch (...) {
75408       {
75409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75410       };
75411     }
75412   }
75413
75414   jresult = result;
75415   return jresult;
75416 }
75417
75418
75419 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMaximumSwipeSpeed(void * jarg1) {
75420   float jresult ;
75421   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75422   float result;
75423
75424   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75425   {
75426     try {
75427       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMaximumSwipeSpeed();
75428     } catch (std::out_of_range& e) {
75429       {
75430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75431       };
75432     } catch (std::exception& e) {
75433       {
75434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75435       };
75436     } catch (Dali::DaliException e) {
75437       {
75438         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75439       };
75440     } catch (...) {
75441       {
75442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75443       };
75444     }
75445   }
75446
75447   jresult = result;
75448   return jresult;
75449 }
75450
75451
75452 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemFlickAnimationDuration(void * jarg1) {
75453   float jresult ;
75454   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75455   float result;
75456
75457   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75458   {
75459     try {
75460       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemFlickAnimationDuration();
75461     } catch (std::out_of_range& e) {
75462       {
75463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75464       };
75465     } catch (std::exception& e) {
75466       {
75467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75468       };
75469     } catch (Dali::DaliException e) {
75470       {
75471         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75472       };
75473     } catch (...) {
75474       {
75475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75476       };
75477     }
75478   }
75479
75480   jresult = result;
75481   return jresult;
75482 }
75483
75484
75485 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetNextFocusItemID(void * jarg1, int jarg2, int jarg3, int jarg4, unsigned int jarg5) {
75486   int jresult ;
75487   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75488   int arg2 ;
75489   int arg3 ;
75490   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
75491   bool arg5 ;
75492   int result;
75493
75494   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75495   arg2 = (int)jarg2;
75496   arg3 = (int)jarg3;
75497   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
75498   arg5 = jarg5 ? true : false;
75499   {
75500     try {
75501       result = (int)(arg1)->GetNextFocusItemID(arg2,arg3,arg4,arg5);
75502     } catch (std::out_of_range& e) {
75503       {
75504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75505       };
75506     } catch (std::exception& e) {
75507       {
75508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75509       };
75510     } catch (Dali::DaliException e) {
75511       {
75512         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75513       };
75514     } catch (...) {
75515       {
75516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75517       };
75518     }
75519   }
75520
75521   jresult = result;
75522   return jresult;
75523 }
75524
75525
75526 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetFlickSpeedFactor(void * jarg1) {
75527   float jresult ;
75528   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75529   float result;
75530
75531   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75532   {
75533     try {
75534       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetFlickSpeedFactor();
75535     } catch (std::out_of_range& e) {
75536       {
75537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75538       };
75539     } catch (std::exception& e) {
75540       {
75541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75542       };
75543     } catch (Dali::DaliException e) {
75544       {
75545         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75546       };
75547     } catch (...) {
75548       {
75549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75550       };
75551     }
75552   }
75553
75554   jresult = result;
75555   return jresult;
75556 }
75557
75558
75559 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_ApplyConstraints(void * jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5) {
75560   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75561   Dali::Actor *arg2 = 0 ;
75562   int arg3 ;
75563   Dali::Vector3 *arg4 = 0 ;
75564   Dali::Actor *arg5 = 0 ;
75565
75566   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75567   arg2 = (Dali::Actor *)jarg2;
75568   if (!arg2) {
75569     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
75570     return ;
75571   }
75572   arg3 = (int)jarg3;
75573   arg4 = (Dali::Vector3 *)jarg4;
75574   if (!arg4) {
75575     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
75576     return ;
75577   }
75578   arg5 = (Dali::Actor *)jarg5;
75579   if (!arg5) {
75580     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
75581     return ;
75582   }
75583   {
75584     try {
75585       (arg1)->ApplyConstraints(*arg2,arg3,(Dali::Vector3 const &)*arg4,(Dali::Actor const &)*arg5);
75586     } catch (std::out_of_range& e) {
75587       {
75588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75589       };
75590     } catch (std::exception& e) {
75591       {
75592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75593       };
75594     } catch (Dali::DaliException e) {
75595       {
75596         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75597       };
75598     } catch (...) {
75599       {
75600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75601       };
75602     }
75603   }
75604
75605 }
75606
75607
75608 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
75609   void * jresult ;
75610   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75611   int arg2 ;
75612   float arg3 ;
75613   Dali::Vector3 *arg4 = 0 ;
75614   Dali::Vector3 result;
75615
75616   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75617   arg2 = (int)jarg2;
75618   arg3 = (float)jarg3;
75619   arg4 = (Dali::Vector3 *)jarg4;
75620   if (!arg4) {
75621     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
75622     return 0;
75623   }
75624   {
75625     try {
75626       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
75627     } catch (std::out_of_range& e) {
75628       {
75629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75630       };
75631     } catch (std::exception& e) {
75632       {
75633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75634       };
75635     } catch (Dali::DaliException e) {
75636       {
75637         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75638       };
75639     } catch (...) {
75640       {
75641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75642       };
75643     }
75644   }
75645
75646   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
75647   return jresult;
75648 }
75649
75650
75651 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NewItemLayout(int jarg1) {
75652   void * jresult ;
75653   Dali::Toolkit::DefaultItemLayout::Type arg1 ;
75654   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
75655
75656   arg1 = (Dali::Toolkit::DefaultItemLayout::Type)jarg1;
75657   {
75658     try {
75659       result = Dali::Toolkit::DefaultItemLayout::New(arg1);
75660     } catch (std::out_of_range& e) {
75661       {
75662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75663       };
75664     } catch (std::exception& e) {
75665       {
75666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75667       };
75668     } catch (Dali::DaliException e) {
75669       {
75670         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75671       };
75672     } catch (...) {
75673       {
75674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75675       };
75676     }
75677   }
75678
75679   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
75680   return jresult;
75681 }
75682
75683
75684 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemFactory(void * jarg1) {
75685   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
75686
75687   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
75688   {
75689     try {
75690       delete arg1;
75691     } catch (std::out_of_range& e) {
75692       {
75693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75694       };
75695     } catch (std::exception& e) {
75696       {
75697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75698       };
75699     } catch (Dali::DaliException e) {
75700       {
75701         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75702       };
75703     } catch (...) {
75704       {
75705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75706       };
75707     }
75708   }
75709
75710 }
75711
75712
75713 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemFactory_GetNumberOfItems(void * jarg1) {
75714   unsigned int jresult ;
75715   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
75716   unsigned int result;
75717
75718   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
75719   {
75720     try {
75721       result = (unsigned int)(arg1)->GetNumberOfItems();
75722     } catch (std::out_of_range& e) {
75723       {
75724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75725       };
75726     } catch (std::exception& e) {
75727       {
75728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75729       };
75730     } catch (Dali::DaliException e) {
75731       {
75732         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75733       };
75734     } catch (...) {
75735       {
75736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75737       };
75738     }
75739   }
75740
75741   jresult = result;
75742   return jresult;
75743 }
75744
75745
75746 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemFactory_NewItem(void * jarg1, unsigned int jarg2) {
75747   void * jresult ;
75748   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
75749   unsigned int arg2 ;
75750   Dali::Actor result;
75751
75752   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
75753   arg2 = (unsigned int)jarg2;
75754   {
75755     try {
75756       result = (arg1)->NewItem(arg2);
75757     } catch (std::out_of_range& e) {
75758       {
75759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75760       };
75761     } catch (std::exception& e) {
75762       {
75763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75764       };
75765     } catch (Dali::DaliException e) {
75766       {
75767         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75768       };
75769     } catch (...) {
75770       {
75771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75772       };
75773     }
75774   }
75775
75776   jresult = new Dali::Actor((const Dali::Actor &)result);
75777   return jresult;
75778 }
75779
75780
75781 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleased(void * jarg1, unsigned int jarg2, void * jarg3) {
75782   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
75783   unsigned int arg2 ;
75784   Dali::Actor arg3 ;
75785   Dali::Actor *argp3 ;
75786
75787   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
75788   arg2 = (unsigned int)jarg2;
75789   argp3 = (Dali::Actor *)jarg3;
75790   if (!argp3) {
75791     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
75792     return ;
75793   }
75794   arg3 = *argp3;
75795   {
75796     try {
75797       (arg1)->ItemReleased(arg2,arg3);
75798     } catch (std::out_of_range& e) {
75799       {
75800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75801       };
75802     } catch (std::exception& e) {
75803       {
75804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75805       };
75806     } catch (Dali::DaliException e) {
75807       {
75808         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75809       };
75810     } catch (...) {
75811       {
75812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75813       };
75814     }
75815   }
75816
75817 }
75818
75819
75820 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleasedSwigExplicitItemFactory(void * jarg1, unsigned int jarg2, void * jarg3) {
75821   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
75822   unsigned int arg2 ;
75823   Dali::Actor arg3 ;
75824   Dali::Actor *argp3 ;
75825
75826   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
75827   arg2 = (unsigned int)jarg2;
75828   argp3 = (Dali::Actor *)jarg3;
75829   if (!argp3) {
75830     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
75831     return ;
75832   }
75833   arg3 = *argp3;
75834   {
75835     try {
75836       (arg1)->Dali::Toolkit::ItemFactory::ItemReleased(arg2,arg3);
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_ItemFactory() {
75860   void * jresult ;
75861   Dali::Toolkit::ItemFactory *result = 0 ;
75862
75863   {
75864     try {
75865       result = (Dali::Toolkit::ItemFactory *)new SwigDirector_ItemFactory();
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_ItemFactory_director_connect(void *objarg, SwigDirector_ItemFactory::SWIG_Callback0_t callback0, SwigDirector_ItemFactory::SWIG_Callback1_t callback1, SwigDirector_ItemFactory::SWIG_Callback2_t callback2) {
75891   Dali::Toolkit::ItemFactory *obj = (Dali::Toolkit::ItemFactory *)objarg;
75892   SwigDirector_ItemFactory *director = dynamic_cast<SwigDirector_ItemFactory *>(obj);
75893   if (director) {
75894     director->swig_connect_director(callback0, callback1, callback2);
75895   }
75896 }
75897
75898
75899 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_SPEED_get() {
75900   int jresult ;
75901   int result;
75902
75903   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_SPEED;
75904   jresult = (int)result;
75905   return jresult;
75906 }
75907
75908
75909 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_DISTANCE_get() {
75910   int jresult ;
75911   int result;
75912
75913   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_DISTANCE;
75914   jresult = (int)result;
75915   return jresult;
75916 }
75917
75918
75919 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
75920   int jresult ;
75921   int result;
75922
75923   result = (int)Dali::Toolkit::ItemView::Property::WHEEL_SCROLL_DISTANCE_STEP;
75924   jresult = (int)result;
75925   return jresult;
75926 }
75927
75928
75929 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SNAP_TO_ITEM_ENABLED_get() {
75930   int jresult ;
75931   int result;
75932
75933   result = (int)Dali::Toolkit::ItemView::Property::SNAP_TO_ITEM_ENABLED;
75934   jresult = (int)result;
75935   return jresult;
75936 }
75937
75938
75939 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_REFRESH_INTERVAL_get() {
75940   int jresult ;
75941   int result;
75942
75943   result = (int)Dali::Toolkit::ItemView::Property::REFRESH_INTERVAL;
75944   jresult = (int)result;
75945   return jresult;
75946 }
75947
75948
75949 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_POSITION_get() {
75950   int jresult ;
75951   int result;
75952
75953   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_POSITION;
75954   jresult = (int)result;
75955   return jresult;
75956 }
75957
75958
75959 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_SPEED_get() {
75960   int jresult ;
75961   int result;
75962
75963   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_SPEED;
75964   jresult = (int)result;
75965   return jresult;
75966 }
75967
75968
75969 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_OVERSHOOT_get() {
75970   int jresult ;
75971   int result;
75972
75973   result = (int)Dali::Toolkit::ItemView::Property::OVERSHOOT;
75974   jresult = (int)result;
75975   return jresult;
75976 }
75977
75978
75979 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_DIRECTION_get() {
75980   int jresult ;
75981   int result;
75982
75983   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_DIRECTION;
75984   jresult = (int)result;
75985   return jresult;
75986 }
75987
75988
75989 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_ORIENTATION_get() {
75990   int jresult ;
75991   int result;
75992
75993   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_ORIENTATION;
75994   jresult = (int)result;
75995   return jresult;
75996 }
75997
75998
75999 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_CONTENT_SIZE_get() {
76000   int jresult ;
76001   int result;
76002
76003   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_CONTENT_SIZE;
76004   jresult = (int)result;
76005   return jresult;
76006 }
76007
76008
76009 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView_Property() {
76010   void * jresult ;
76011   Dali::Toolkit::ItemView::Property *result = 0 ;
76012
76013   {
76014     try {
76015       result = (Dali::Toolkit::ItemView::Property *)new Dali::Toolkit::ItemView::Property();
76016     } catch (std::out_of_range& e) {
76017       {
76018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76019       };
76020     } catch (std::exception& e) {
76021       {
76022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76023       };
76024     } catch (Dali::DaliException e) {
76025       {
76026         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76027       };
76028     } catch (...) {
76029       {
76030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76031       };
76032     }
76033   }
76034
76035   jresult = (void *)result;
76036   return jresult;
76037 }
76038
76039
76040 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView_Property(void * jarg1) {
76041   Dali::Toolkit::ItemView::Property *arg1 = (Dali::Toolkit::ItemView::Property *) 0 ;
76042
76043   arg1 = (Dali::Toolkit::ItemView::Property *)jarg1;
76044   {
76045     try {
76046       delete arg1;
76047     } catch (std::out_of_range& e) {
76048       {
76049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76050       };
76051     } catch (std::exception& e) {
76052       {
76053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76054       };
76055     } catch (Dali::DaliException e) {
76056       {
76057         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76058       };
76059     } catch (...) {
76060       {
76061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76062       };
76063     }
76064   }
76065
76066 }
76067
76068
76069 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_0() {
76070   void * jresult ;
76071   Dali::Toolkit::ItemView *result = 0 ;
76072
76073   {
76074     try {
76075       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView();
76076     } catch (std::out_of_range& e) {
76077       {
76078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76079       };
76080     } catch (std::exception& e) {
76081       {
76082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76083       };
76084     } catch (Dali::DaliException e) {
76085       {
76086         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76087       };
76088     } catch (...) {
76089       {
76090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76091       };
76092     }
76093   }
76094
76095   jresult = (void *)result;
76096   return jresult;
76097 }
76098
76099
76100 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_1(void * jarg1) {
76101   void * jresult ;
76102   Dali::Toolkit::ItemView *arg1 = 0 ;
76103   Dali::Toolkit::ItemView *result = 0 ;
76104
76105   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76106   if (!arg1) {
76107     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
76108     return 0;
76109   }
76110   {
76111     try {
76112       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView((Dali::Toolkit::ItemView const &)*arg1);
76113     } catch (std::out_of_range& e) {
76114       {
76115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76116       };
76117     } catch (std::exception& e) {
76118       {
76119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76120       };
76121     } catch (Dali::DaliException e) {
76122       {
76123         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76124       };
76125     } catch (...) {
76126       {
76127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76128       };
76129     }
76130   }
76131
76132   jresult = (void *)result;
76133   return jresult;
76134 }
76135
76136
76137 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_Assign(void * jarg1, void * jarg2) {
76138   void * jresult ;
76139   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76140   Dali::Toolkit::ItemView *arg2 = 0 ;
76141   Dali::Toolkit::ItemView *result = 0 ;
76142
76143   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76144   arg2 = (Dali::Toolkit::ItemView *)jarg2;
76145   if (!arg2) {
76146     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
76147     return 0;
76148   }
76149   {
76150     try {
76151       result = (Dali::Toolkit::ItemView *) &(arg1)->operator =((Dali::Toolkit::ItemView const &)*arg2);
76152     } catch (std::out_of_range& e) {
76153       {
76154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76155       };
76156     } catch (std::exception& e) {
76157       {
76158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76159       };
76160     } catch (Dali::DaliException e) {
76161       {
76162         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76163       };
76164     } catch (...) {
76165       {
76166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76167       };
76168     }
76169   }
76170
76171   jresult = (void *)result;
76172   return jresult;
76173 }
76174
76175
76176 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView(void * jarg1) {
76177   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76178
76179   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76180   {
76181     try {
76182       delete arg1;
76183     } catch (std::out_of_range& e) {
76184       {
76185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76186       };
76187     } catch (std::exception& e) {
76188       {
76189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76190       };
76191     } catch (Dali::DaliException e) {
76192       {
76193         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76194       };
76195     } catch (...) {
76196       {
76197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76198       };
76199     }
76200   }
76201
76202 }
76203
76204
76205 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_New(void * jarg1) {
76206   void * jresult ;
76207   Dali::Toolkit::ItemFactory *arg1 = 0 ;
76208   Dali::Toolkit::ItemView result;
76209
76210   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
76211   if (!arg1) {
76212     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemFactory & type is null", 0);
76213     return 0;
76214   }
76215   {
76216     try {
76217       result = Dali::Toolkit::ItemView::New(*arg1);
76218     } catch (std::out_of_range& e) {
76219       {
76220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76221       };
76222     } catch (std::exception& e) {
76223       {
76224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76225       };
76226     } catch (Dali::DaliException e) {
76227       {
76228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76229       };
76230     } catch (...) {
76231       {
76232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76233       };
76234     }
76235   }
76236
76237   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
76238   return jresult;
76239 }
76240
76241
76242 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_DownCast(void * jarg1) {
76243   void * jresult ;
76244   Dali::BaseHandle arg1 ;
76245   Dali::BaseHandle *argp1 ;
76246   Dali::Toolkit::ItemView result;
76247
76248   argp1 = (Dali::BaseHandle *)jarg1;
76249   if (!argp1) {
76250     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
76251     return 0;
76252   }
76253   arg1 = *argp1;
76254   {
76255     try {
76256       result = Dali::Toolkit::ItemView::DownCast(arg1);
76257     } catch (std::out_of_range& e) {
76258       {
76259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76260       };
76261     } catch (std::exception& e) {
76262       {
76263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76264       };
76265     } catch (Dali::DaliException e) {
76266       {
76267         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76268       };
76269     } catch (...) {
76270       {
76271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76272       };
76273     }
76274   }
76275
76276   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
76277   return jresult;
76278 }
76279
76280
76281 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetLayoutCount(void * jarg1) {
76282   unsigned int jresult ;
76283   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76284   unsigned int result;
76285
76286   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76287   {
76288     try {
76289       result = (unsigned int)((Dali::Toolkit::ItemView const *)arg1)->GetLayoutCount();
76290     } catch (std::out_of_range& e) {
76291       {
76292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76293       };
76294     } catch (std::exception& e) {
76295       {
76296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76297       };
76298     } catch (Dali::DaliException e) {
76299       {
76300         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76301       };
76302     } catch (...) {
76303       {
76304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76305       };
76306     }
76307   }
76308
76309   jresult = result;
76310   return jresult;
76311 }
76312
76313
76314 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_AddLayout(void * jarg1, void * jarg2) {
76315   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76316   Dali::Toolkit::ItemLayout *arg2 = 0 ;
76317
76318   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76319   arg2 = (Dali::Toolkit::ItemLayout *)jarg2;
76320   if (!arg2) {
76321     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemLayout & type is null", 0);
76322     return ;
76323   }
76324   {
76325     try {
76326       (arg1)->AddLayout(*arg2);
76327     } catch (std::out_of_range& e) {
76328       {
76329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76330       };
76331     } catch (std::exception& e) {
76332       {
76333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76334       };
76335     } catch (Dali::DaliException e) {
76336       {
76337         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76338       };
76339     } catch (...) {
76340       {
76341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76342       };
76343     }
76344   }
76345
76346 }
76347
76348
76349 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveLayout(void * jarg1, unsigned int jarg2) {
76350   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76351   unsigned int arg2 ;
76352
76353   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76354   arg2 = (unsigned int)jarg2;
76355   {
76356     try {
76357       (arg1)->RemoveLayout(arg2);
76358     } catch (std::out_of_range& e) {
76359       {
76360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76361       };
76362     } catch (std::exception& e) {
76363       {
76364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76365       };
76366     } catch (Dali::DaliException e) {
76367       {
76368         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76369       };
76370     } catch (...) {
76371       {
76372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76373       };
76374     }
76375   }
76376
76377 }
76378
76379
76380 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetLayout(void * jarg1, unsigned int jarg2) {
76381   void * jresult ;
76382   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76383   unsigned int arg2 ;
76384   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
76385
76386   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76387   arg2 = (unsigned int)jarg2;
76388   {
76389     try {
76390       result = ((Dali::Toolkit::ItemView const *)arg1)->GetLayout(arg2);
76391     } catch (std::out_of_range& e) {
76392       {
76393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76394       };
76395     } catch (std::exception& e) {
76396       {
76397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76398       };
76399     } catch (Dali::DaliException e) {
76400       {
76401         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76402       };
76403     } catch (...) {
76404       {
76405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76406       };
76407     }
76408   }
76409
76410   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
76411   return jresult;
76412 }
76413
76414
76415 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetActiveLayout(void * jarg1) {
76416   void * jresult ;
76417   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76418   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
76419
76420   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76421   {
76422     try {
76423       result = ((Dali::Toolkit::ItemView const *)arg1)->GetActiveLayout();
76424     } catch (std::out_of_range& e) {
76425       {
76426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76427       };
76428     } catch (std::exception& e) {
76429       {
76430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76431       };
76432     } catch (Dali::DaliException e) {
76433       {
76434         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76435       };
76436     } catch (...) {
76437       {
76438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76439       };
76440     }
76441   }
76442
76443   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
76444   return jresult;
76445 }
76446
76447
76448 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetCurrentLayoutPosition(void * jarg1, unsigned int jarg2) {
76449   float jresult ;
76450   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76451   Dali::Toolkit::ItemId arg2 ;
76452   float result;
76453
76454   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76455   arg2 = (Dali::Toolkit::ItemId)jarg2;
76456   {
76457     try {
76458       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetCurrentLayoutPosition(arg2);
76459     } catch (std::out_of_range& e) {
76460       {
76461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76462       };
76463     } catch (std::exception& e) {
76464       {
76465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76466       };
76467     } catch (Dali::DaliException e) {
76468       {
76469         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76470       };
76471     } catch (...) {
76472       {
76473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76474       };
76475     }
76476   }
76477
76478   jresult = result;
76479   return jresult;
76480 }
76481
76482
76483 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ActivateLayout(void * jarg1, unsigned int jarg2, void * jarg3, float jarg4) {
76484   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76485   unsigned int arg2 ;
76486   Dali::Vector3 arg3 ;
76487   float arg4 ;
76488   Dali::Vector3 *argp3 ;
76489
76490   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76491   arg2 = (unsigned int)jarg2;
76492   argp3 = (Dali::Vector3 *)jarg3;
76493   if (!argp3) {
76494     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
76495     return ;
76496   }
76497   arg3 = *argp3;
76498   arg4 = (float)jarg4;
76499   {
76500     try {
76501       (arg1)->ActivateLayout(arg2,arg3,arg4);
76502     } catch (std::out_of_range& e) {
76503       {
76504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76505       };
76506     } catch (std::exception& e) {
76507       {
76508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76509       };
76510     } catch (Dali::DaliException e) {
76511       {
76512         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76513       };
76514     } catch (...) {
76515       {
76516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76517       };
76518     }
76519   }
76520
76521 }
76522
76523
76524 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_DeactivateCurrentLayout(void * jarg1) {
76525   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76526
76527   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76528   {
76529     try {
76530       (arg1)->DeactivateCurrentLayout();
76531     } catch (std::out_of_range& e) {
76532       {
76533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76534       };
76535     } catch (std::exception& e) {
76536       {
76537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76538       };
76539     } catch (Dali::DaliException e) {
76540       {
76541         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76542       };
76543     } catch (...) {
76544       {
76545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76546       };
76547     }
76548   }
76549
76550 }
76551
76552
76553 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeSpeed(void * jarg1, float jarg2) {
76554   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76555   float arg2 ;
76556
76557   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76558   arg2 = (float)jarg2;
76559   {
76560     try {
76561       (arg1)->SetMinimumSwipeSpeed(arg2);
76562     } catch (std::out_of_range& e) {
76563       {
76564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76565       };
76566     } catch (std::exception& e) {
76567       {
76568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76569       };
76570     } catch (Dali::DaliException e) {
76571       {
76572         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76573       };
76574     } catch (...) {
76575       {
76576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76577       };
76578     }
76579   }
76580
76581 }
76582
76583
76584 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeSpeed(void * jarg1) {
76585   float jresult ;
76586   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76587   float result;
76588
76589   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76590   {
76591     try {
76592       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeSpeed();
76593     } catch (std::out_of_range& e) {
76594       {
76595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76596       };
76597     } catch (std::exception& e) {
76598       {
76599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76600       };
76601     } catch (Dali::DaliException e) {
76602       {
76603         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76604       };
76605     } catch (...) {
76606       {
76607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76608       };
76609     }
76610   }
76611
76612   jresult = result;
76613   return jresult;
76614 }
76615
76616
76617 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeDistance(void * jarg1, float jarg2) {
76618   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76619   float arg2 ;
76620
76621   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76622   arg2 = (float)jarg2;
76623   {
76624     try {
76625       (arg1)->SetMinimumSwipeDistance(arg2);
76626     } catch (std::out_of_range& e) {
76627       {
76628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76629       };
76630     } catch (std::exception& e) {
76631       {
76632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76633       };
76634     } catch (Dali::DaliException e) {
76635       {
76636         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76637       };
76638     } catch (...) {
76639       {
76640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76641       };
76642     }
76643   }
76644
76645 }
76646
76647
76648 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeDistance(void * jarg1) {
76649   float jresult ;
76650   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76651   float result;
76652
76653   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76654   {
76655     try {
76656       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeDistance();
76657     } catch (std::out_of_range& e) {
76658       {
76659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76660       };
76661     } catch (std::exception& e) {
76662       {
76663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76664       };
76665     } catch (Dali::DaliException e) {
76666       {
76667         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76668       };
76669     } catch (...) {
76670       {
76671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76672       };
76673     }
76674   }
76675
76676   jresult = result;
76677   return jresult;
76678 }
76679
76680
76681 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetWheelScrollDistanceStep(void * jarg1, float jarg2) {
76682   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76683   float arg2 ;
76684
76685   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76686   arg2 = (float)jarg2;
76687   {
76688     try {
76689       (arg1)->SetWheelScrollDistanceStep(arg2);
76690     } catch (std::out_of_range& e) {
76691       {
76692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76693       };
76694     } catch (std::exception& e) {
76695       {
76696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76697       };
76698     } catch (Dali::DaliException e) {
76699       {
76700         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76701       };
76702     } catch (...) {
76703       {
76704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76705       };
76706     }
76707   }
76708
76709 }
76710
76711
76712 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetWheelScrollDistanceStep(void * jarg1) {
76713   float jresult ;
76714   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76715   float result;
76716
76717   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76718   {
76719     try {
76720       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetWheelScrollDistanceStep();
76721     } catch (std::out_of_range& e) {
76722       {
76723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76724       };
76725     } catch (std::exception& e) {
76726       {
76727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76728       };
76729     } catch (Dali::DaliException e) {
76730       {
76731         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76732       };
76733     } catch (...) {
76734       {
76735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76736       };
76737     }
76738   }
76739
76740   jresult = result;
76741   return jresult;
76742 }
76743
76744
76745 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoring(void * jarg1, unsigned int jarg2) {
76746   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76747   bool arg2 ;
76748
76749   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76750   arg2 = jarg2 ? true : false;
76751   {
76752     try {
76753       (arg1)->SetAnchoring(arg2);
76754     } catch (std::out_of_range& e) {
76755       {
76756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76757       };
76758     } catch (std::exception& e) {
76759       {
76760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76761       };
76762     } catch (Dali::DaliException e) {
76763       {
76764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76765       };
76766     } catch (...) {
76767       {
76768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76769       };
76770     }
76771   }
76772
76773 }
76774
76775 //// ========================= end of part 3 =============================
76776
76777 //// ========================== start part 4 ===============================
76778
76779
76780 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoring(void * jarg1) {
76781   unsigned int jresult ;
76782   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76783   bool result;
76784
76785   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76786   {
76787     try {
76788       result = (bool)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoring();
76789     } catch (std::out_of_range& e) {
76790       {
76791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76792       };
76793     } catch (std::exception& e) {
76794       {
76795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76796       };
76797     } catch (Dali::DaliException e) {
76798       {
76799         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76800       };
76801     } catch (...) {
76802       {
76803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76804       };
76805     }
76806   }
76807
76808   jresult = result;
76809   return jresult;
76810 }
76811
76812
76813 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoringDuration(void * jarg1, float jarg2) {
76814   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76815   float arg2 ;
76816
76817   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76818   arg2 = (float)jarg2;
76819   {
76820     try {
76821       (arg1)->SetAnchoringDuration(arg2);
76822     } catch (std::out_of_range& e) {
76823       {
76824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76825       };
76826     } catch (std::exception& e) {
76827       {
76828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76829       };
76830     } catch (Dali::DaliException e) {
76831       {
76832         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76833       };
76834     } catch (...) {
76835       {
76836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76837       };
76838     }
76839   }
76840
76841 }
76842
76843
76844 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoringDuration(void * jarg1) {
76845   float jresult ;
76846   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76847   float result;
76848
76849   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76850   {
76851     try {
76852       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoringDuration();
76853     } catch (std::out_of_range& e) {
76854       {
76855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76856       };
76857     } catch (std::exception& e) {
76858       {
76859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76860       };
76861     } catch (Dali::DaliException e) {
76862       {
76863         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76864       };
76865     } catch (...) {
76866       {
76867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76868       };
76869     }
76870   }
76871
76872   jresult = result;
76873   return jresult;
76874 }
76875
76876
76877 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ScrollToItem(void * jarg1, unsigned int jarg2, float jarg3) {
76878   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76879   Dali::Toolkit::ItemId arg2 ;
76880   float arg3 ;
76881
76882   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76883   arg2 = (Dali::Toolkit::ItemId)jarg2;
76884   arg3 = (float)jarg3;
76885   {
76886     try {
76887       (arg1)->ScrollToItem(arg2,arg3);
76888     } catch (std::out_of_range& e) {
76889       {
76890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76891       };
76892     } catch (std::exception& e) {
76893       {
76894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76895       };
76896     } catch (Dali::DaliException e) {
76897       {
76898         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76899       };
76900     } catch (...) {
76901       {
76902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76903       };
76904     }
76905   }
76906
76907 }
76908
76909
76910 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetRefreshInterval(void * jarg1, float jarg2) {
76911   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76912   float arg2 ;
76913
76914   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76915   arg2 = (float)jarg2;
76916   {
76917     try {
76918       (arg1)->SetRefreshInterval(arg2);
76919     } catch (std::out_of_range& e) {
76920       {
76921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76922       };
76923     } catch (std::exception& e) {
76924       {
76925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76926       };
76927     } catch (Dali::DaliException e) {
76928       {
76929         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76930       };
76931     } catch (...) {
76932       {
76933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76934       };
76935     }
76936   }
76937
76938 }
76939
76940
76941 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetRefreshInterval(void * jarg1) {
76942   float jresult ;
76943   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76944   float result;
76945
76946   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76947   {
76948     try {
76949       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetRefreshInterval();
76950     } catch (std::out_of_range& e) {
76951       {
76952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76953       };
76954     } catch (std::exception& e) {
76955       {
76956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76957       };
76958     } catch (Dali::DaliException e) {
76959       {
76960         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76961       };
76962     } catch (...) {
76963       {
76964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76965       };
76966     }
76967   }
76968
76969   jresult = result;
76970   return jresult;
76971 }
76972
76973
76974 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_Refresh(void * jarg1) {
76975   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76976
76977   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76978   {
76979     try {
76980       (arg1)->Refresh();
76981     } catch (std::out_of_range& e) {
76982       {
76983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76984       };
76985     } catch (std::exception& e) {
76986       {
76987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76988       };
76989     } catch (Dali::DaliException e) {
76990       {
76991         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76992       };
76993     } catch (...) {
76994       {
76995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76996       };
76997     }
76998   }
76999
77000 }
77001
77002
77003 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItem(void * jarg1, unsigned int jarg2) {
77004   void * jresult ;
77005   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77006   Dali::Toolkit::ItemId arg2 ;
77007   Dali::Actor result;
77008
77009   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77010   arg2 = (Dali::Toolkit::ItemId)jarg2;
77011   {
77012     try {
77013       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItem(arg2);
77014     } catch (std::out_of_range& e) {
77015       {
77016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77017       };
77018     } catch (std::exception& e) {
77019       {
77020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77021       };
77022     } catch (Dali::DaliException e) {
77023       {
77024         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77025       };
77026     } catch (...) {
77027       {
77028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77029       };
77030     }
77031   }
77032
77033   jresult = new Dali::Actor((const Dali::Actor &)result);
77034   return jresult;
77035 }
77036
77037
77038 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetItemId(void * jarg1, void * jarg2) {
77039   unsigned int jresult ;
77040   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77041   Dali::Actor arg2 ;
77042   Dali::Actor *argp2 ;
77043   Dali::Toolkit::ItemId result;
77044
77045   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77046   argp2 = (Dali::Actor *)jarg2;
77047   if (!argp2) {
77048     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
77049     return 0;
77050   }
77051   arg2 = *argp2;
77052   {
77053     try {
77054       result = (Dali::Toolkit::ItemId)((Dali::Toolkit::ItemView const *)arg1)->GetItemId(arg2);
77055     } catch (std::out_of_range& e) {
77056       {
77057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77058       };
77059     } catch (std::exception& e) {
77060       {
77061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77062       };
77063     } catch (Dali::DaliException e) {
77064       {
77065         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77066       };
77067     } catch (...) {
77068       {
77069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77070       };
77071     }
77072   }
77073
77074   jresult = result;
77075   return jresult;
77076 }
77077
77078
77079 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItem(void * jarg1, void * jarg2, float jarg3) {
77080   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77081   Dali::Toolkit::Item arg2 ;
77082   float arg3 ;
77083   Dali::Toolkit::Item *argp2 ;
77084
77085   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77086   argp2 = (Dali::Toolkit::Item *)jarg2;
77087   if (!argp2) {
77088     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
77089     return ;
77090   }
77091   arg2 = *argp2;
77092   arg3 = (float)jarg3;
77093   {
77094     try {
77095       (arg1)->InsertItem(arg2,arg3);
77096     } catch (std::out_of_range& e) {
77097       {
77098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77099       };
77100     } catch (std::exception& e) {
77101       {
77102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77103       };
77104     } catch (Dali::DaliException e) {
77105       {
77106         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77107       };
77108     } catch (...) {
77109       {
77110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77111       };
77112     }
77113   }
77114
77115 }
77116
77117
77118 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItems(void * jarg1, void * jarg2, float jarg3) {
77119   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77120   Dali::Toolkit::ItemContainer *arg2 = 0 ;
77121   float arg3 ;
77122
77123   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77124   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
77125   if (!arg2) {
77126     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
77127     return ;
77128   }
77129   arg3 = (float)jarg3;
77130   {
77131     try {
77132       (arg1)->InsertItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
77133     } catch (std::out_of_range& e) {
77134       {
77135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77136       };
77137     } catch (std::exception& e) {
77138       {
77139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77140       };
77141     } catch (Dali::DaliException e) {
77142       {
77143         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77144       };
77145     } catch (...) {
77146       {
77147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77148       };
77149     }
77150   }
77151
77152 }
77153
77154
77155 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItem(void * jarg1, unsigned int jarg2, float jarg3) {
77156   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77157   Dali::Toolkit::ItemId arg2 ;
77158   float arg3 ;
77159
77160   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77161   arg2 = (Dali::Toolkit::ItemId)jarg2;
77162   arg3 = (float)jarg3;
77163   {
77164     try {
77165       (arg1)->RemoveItem(arg2,arg3);
77166     } catch (std::out_of_range& e) {
77167       {
77168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77169       };
77170     } catch (std::exception& e) {
77171       {
77172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77173       };
77174     } catch (Dali::DaliException e) {
77175       {
77176         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77177       };
77178     } catch (...) {
77179       {
77180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77181       };
77182     }
77183   }
77184
77185 }
77186
77187
77188 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItems(void * jarg1, void * jarg2, float jarg3) {
77189   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77190   Dali::Toolkit::ItemIdContainer *arg2 = 0 ;
77191   float arg3 ;
77192
77193   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77194   arg2 = (Dali::Toolkit::ItemIdContainer *)jarg2;
77195   if (!arg2) {
77196     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemIdContainer const & type is null", 0);
77197     return ;
77198   }
77199   arg3 = (float)jarg3;
77200   {
77201     try {
77202       (arg1)->RemoveItems((Dali::Toolkit::ItemIdContainer const &)*arg2,arg3);
77203     } catch (std::out_of_range& e) {
77204       {
77205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77206       };
77207     } catch (std::exception& e) {
77208       {
77209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77210       };
77211     } catch (Dali::DaliException e) {
77212       {
77213         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77214       };
77215     } catch (...) {
77216       {
77217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77218       };
77219     }
77220   }
77221
77222 }
77223
77224
77225 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItem(void * jarg1, void * jarg2, float jarg3) {
77226   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77227   Dali::Toolkit::Item arg2 ;
77228   float arg3 ;
77229   Dali::Toolkit::Item *argp2 ;
77230
77231   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77232   argp2 = (Dali::Toolkit::Item *)jarg2;
77233   if (!argp2) {
77234     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
77235     return ;
77236   }
77237   arg2 = *argp2;
77238   arg3 = (float)jarg3;
77239   {
77240     try {
77241       (arg1)->ReplaceItem(arg2,arg3);
77242     } catch (std::out_of_range& e) {
77243       {
77244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77245       };
77246     } catch (std::exception& e) {
77247       {
77248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77249       };
77250     } catch (Dali::DaliException e) {
77251       {
77252         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77253       };
77254     } catch (...) {
77255       {
77256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77257       };
77258     }
77259   }
77260
77261 }
77262
77263
77264 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItems(void * jarg1, void * jarg2, float jarg3) {
77265   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77266   Dali::Toolkit::ItemContainer *arg2 = 0 ;
77267   float arg3 ;
77268
77269   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77270   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
77271   if (!arg2) {
77272     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
77273     return ;
77274   }
77275   arg3 = (float)jarg3;
77276   {
77277     try {
77278       (arg1)->ReplaceItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
77279     } catch (std::out_of_range& e) {
77280       {
77281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77282       };
77283     } catch (std::exception& e) {
77284       {
77285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77286       };
77287     } catch (Dali::DaliException e) {
77288       {
77289         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77290       };
77291     } catch (...) {
77292       {
77293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77294       };
77295     }
77296   }
77297
77298 }
77299
77300
77301 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsParentOrigin(void * jarg1, void * jarg2) {
77302   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77303   Dali::Vector3 *arg2 = 0 ;
77304
77305   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77306   arg2 = (Dali::Vector3 *)jarg2;
77307   if (!arg2) {
77308     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
77309     return ;
77310   }
77311   {
77312     try {
77313       (arg1)->SetItemsParentOrigin((Dali::Vector3 const &)*arg2);
77314     } catch (std::out_of_range& e) {
77315       {
77316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77317       };
77318     } catch (std::exception& e) {
77319       {
77320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77321       };
77322     } catch (Dali::DaliException e) {
77323       {
77324         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77325       };
77326     } catch (...) {
77327       {
77328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77329       };
77330     }
77331   }
77332
77333 }
77334
77335
77336 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsParentOrigin(void * jarg1) {
77337   void * jresult ;
77338   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77339   Dali::Vector3 result;
77340
77341   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77342   {
77343     try {
77344       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsParentOrigin();
77345     } catch (std::out_of_range& e) {
77346       {
77347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77348       };
77349     } catch (std::exception& e) {
77350       {
77351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77352       };
77353     } catch (Dali::DaliException e) {
77354       {
77355         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77356       };
77357     } catch (...) {
77358       {
77359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77360       };
77361     }
77362   }
77363
77364   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
77365   return jresult;
77366 }
77367
77368
77369 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsAnchorPoint(void * jarg1, void * jarg2) {
77370   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77371   Dali::Vector3 *arg2 = 0 ;
77372
77373   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77374   arg2 = (Dali::Vector3 *)jarg2;
77375   if (!arg2) {
77376     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
77377     return ;
77378   }
77379   {
77380     try {
77381       (arg1)->SetItemsAnchorPoint((Dali::Vector3 const &)*arg2);
77382     } catch (std::out_of_range& e) {
77383       {
77384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77385       };
77386     } catch (std::exception& e) {
77387       {
77388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77389       };
77390     } catch (Dali::DaliException e) {
77391       {
77392         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77393       };
77394     } catch (...) {
77395       {
77396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77397       };
77398     }
77399   }
77400
77401 }
77402
77403
77404 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsAnchorPoint(void * jarg1) {
77405   void * jresult ;
77406   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77407   Dali::Vector3 result;
77408
77409   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77410   {
77411     try {
77412       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsAnchorPoint();
77413     } catch (std::out_of_range& e) {
77414       {
77415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77416       };
77417     } catch (std::exception& e) {
77418       {
77419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77420       };
77421     } catch (Dali::DaliException e) {
77422       {
77423         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77424       };
77425     } catch (...) {
77426       {
77427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77428       };
77429     }
77430   }
77431
77432   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
77433   return jresult;
77434 }
77435
77436
77437 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_GetItemsRange(void * jarg1, void * jarg2) {
77438   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77439   Dali::Toolkit::ItemRange *arg2 = 0 ;
77440
77441   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77442   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
77443   if (!arg2) {
77444     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange & type is null", 0);
77445     return ;
77446   }
77447   {
77448     try {
77449       (arg1)->GetItemsRange(*arg2);
77450     } catch (std::out_of_range& e) {
77451       {
77452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77453       };
77454     } catch (std::exception& e) {
77455       {
77456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77457       };
77458     } catch (Dali::DaliException e) {
77459       {
77460         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77461       };
77462     } catch (...) {
77463       {
77464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77465       };
77466     }
77467   }
77468
77469 }
77470
77471
77472 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_LayoutActivatedSignal(void * jarg1) {
77473   void * jresult ;
77474   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77475   Dali::Toolkit::ItemView::LayoutActivatedSignalType *result = 0 ;
77476
77477   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77478   {
77479     try {
77480       result = (Dali::Toolkit::ItemView::LayoutActivatedSignalType *) &(arg1)->LayoutActivatedSignal();
77481     } catch (std::out_of_range& e) {
77482       {
77483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77484       };
77485     } catch (std::exception& e) {
77486       {
77487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77488       };
77489     } catch (Dali::DaliException e) {
77490       {
77491         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77492       };
77493     } catch (...) {
77494       {
77495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77496       };
77497     }
77498   }
77499
77500   jresult = (void *)result;
77501   return jresult;
77502 }
77503
77504
77505 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MoveActorConstraint(void * jarg1, void * jarg2) {
77506   Dali::Vector3 *arg1 = 0 ;
77507   PropertyInputContainer *arg2 = 0 ;
77508
77509   arg1 = (Dali::Vector3 *)jarg1;
77510   if (!arg1) {
77511     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
77512     return ;
77513   }
77514   arg2 = (PropertyInputContainer *)jarg2;
77515   if (!arg2) {
77516     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
77517     return ;
77518   }
77519   {
77520     try {
77521       Dali::Toolkit::MoveActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
77522     } catch (std::out_of_range& e) {
77523       {
77524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77525       };
77526     } catch (std::exception& e) {
77527       {
77528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77529       };
77530     } catch (Dali::DaliException e) {
77531       {
77532         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77533       };
77534     } catch (...) {
77535       {
77536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77537       };
77538     }
77539   }
77540
77541 }
77542
77543
77544 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WrapActorConstraint(void * jarg1, void * jarg2) {
77545   Dali::Vector3 *arg1 = 0 ;
77546   PropertyInputContainer *arg2 = 0 ;
77547
77548   arg1 = (Dali::Vector3 *)jarg1;
77549   if (!arg1) {
77550     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
77551     return ;
77552   }
77553   arg2 = (PropertyInputContainer *)jarg2;
77554   if (!arg2) {
77555     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
77556     return ;
77557   }
77558   {
77559     try {
77560       Dali::Toolkit::WrapActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
77561     } catch (std::out_of_range& e) {
77562       {
77563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77564       };
77565     } catch (std::exception& e) {
77566       {
77567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77568       };
77569     } catch (Dali::DaliException e) {
77570       {
77571         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77572       };
77573     } catch (...) {
77574       {
77575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77576       };
77577     }
77578   }
77579
77580 }
77581
77582
77583 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewEffect() {
77584   void * jresult ;
77585   Dali::Toolkit::ScrollViewEffect *result = 0 ;
77586
77587   {
77588     try {
77589       result = (Dali::Toolkit::ScrollViewEffect *)new Dali::Toolkit::ScrollViewEffect();
77590     } catch (std::out_of_range& e) {
77591       {
77592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77593       };
77594     } catch (std::exception& e) {
77595       {
77596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77597       };
77598     } catch (Dali::DaliException e) {
77599       {
77600         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77601       };
77602     } catch (...) {
77603       {
77604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77605       };
77606     }
77607   }
77608
77609   jresult = (void *)result;
77610   return jresult;
77611 }
77612
77613
77614 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewEffect(void * jarg1) {
77615   Dali::Toolkit::ScrollViewEffect *arg1 = (Dali::Toolkit::ScrollViewEffect *) 0 ;
77616
77617   arg1 = (Dali::Toolkit::ScrollViewEffect *)jarg1;
77618   {
77619     try {
77620       delete arg1;
77621     } catch (std::out_of_range& e) {
77622       {
77623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77624       };
77625     } catch (std::exception& e) {
77626       {
77627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77628       };
77629     } catch (Dali::DaliException e) {
77630       {
77631         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77632       };
77633     } catch (...) {
77634       {
77635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77636       };
77637     }
77638   }
77639
77640 }
77641
77642
77643 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_New(void * jarg1, void * jarg2, int jarg3, void * jarg4, unsigned int jarg5) {
77644   void * jresult ;
77645   Dali::Path arg1 ;
77646   Dali::Vector3 *arg2 = 0 ;
77647   Dali::Property::Index arg3 ;
77648   Dali::Vector3 *arg4 = 0 ;
77649   unsigned int arg5 ;
77650   Dali::Path *argp1 ;
77651   Dali::Toolkit::ScrollViewPagePathEffect result;
77652
77653   argp1 = (Dali::Path *)jarg1;
77654   if (!argp1) {
77655     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
77656     return 0;
77657   }
77658   arg1 = *argp1;
77659   arg2 = (Dali::Vector3 *)jarg2;
77660   if (!arg2) {
77661     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
77662     return 0;
77663   }
77664   arg3 = (Dali::Property::Index)jarg3;
77665   arg4 = (Dali::Vector3 *)jarg4;
77666   if (!arg4) {
77667     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
77668     return 0;
77669   }
77670   arg5 = (unsigned int)jarg5;
77671   {
77672     try {
77673       result = Dali::Toolkit::ScrollViewPagePathEffect::New(arg1,(Dali::Vector3 const &)*arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
77674     } catch (std::out_of_range& e) {
77675       {
77676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77677       };
77678     } catch (std::exception& e) {
77679       {
77680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77681       };
77682     } catch (Dali::DaliException e) {
77683       {
77684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77685       };
77686     } catch (...) {
77687       {
77688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77689       };
77690     }
77691   }
77692
77693   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
77694   return jresult;
77695 }
77696
77697
77698 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewPagePathEffect() {
77699   void * jresult ;
77700   Dali::Toolkit::ScrollViewPagePathEffect *result = 0 ;
77701
77702   {
77703     try {
77704       result = (Dali::Toolkit::ScrollViewPagePathEffect *)new Dali::Toolkit::ScrollViewPagePathEffect();
77705     } catch (std::out_of_range& e) {
77706       {
77707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77708       };
77709     } catch (std::exception& e) {
77710       {
77711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77712       };
77713     } catch (Dali::DaliException e) {
77714       {
77715         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77716       };
77717     } catch (...) {
77718       {
77719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77720       };
77721     }
77722   }
77723
77724   jresult = (void *)result;
77725   return jresult;
77726 }
77727
77728
77729 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_DownCast(void * jarg1) {
77730   void * jresult ;
77731   Dali::BaseHandle arg1 ;
77732   Dali::BaseHandle *argp1 ;
77733   Dali::Toolkit::ScrollViewPagePathEffect result;
77734
77735   argp1 = (Dali::BaseHandle *)jarg1;
77736   if (!argp1) {
77737     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
77738     return 0;
77739   }
77740   arg1 = *argp1;
77741   {
77742     try {
77743       result = Dali::Toolkit::ScrollViewPagePathEffect::DownCast(arg1);
77744     } catch (std::out_of_range& e) {
77745       {
77746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77747       };
77748     } catch (std::exception& e) {
77749       {
77750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77751       };
77752     } catch (Dali::DaliException e) {
77753       {
77754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77755       };
77756     } catch (...) {
77757       {
77758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77759       };
77760     }
77761   }
77762
77763   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
77764   return jresult;
77765 }
77766
77767
77768 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_ApplyToPage(void * jarg1, void * jarg2, unsigned int jarg3) {
77769   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
77770   Dali::Actor arg2 ;
77771   unsigned int arg3 ;
77772   Dali::Actor *argp2 ;
77773
77774   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
77775   argp2 = (Dali::Actor *)jarg2;
77776   if (!argp2) {
77777     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
77778     return ;
77779   }
77780   arg2 = *argp2;
77781   arg3 = (unsigned int)jarg3;
77782   {
77783     try {
77784       (arg1)->ApplyToPage(arg2,arg3);
77785     } catch (std::out_of_range& e) {
77786       {
77787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77788       };
77789     } catch (std::exception& e) {
77790       {
77791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77792       };
77793     } catch (Dali::DaliException e) {
77794       {
77795         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77796       };
77797     } catch (...) {
77798       {
77799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77800       };
77801     }
77802   }
77803
77804 }
77805
77806
77807 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewPagePathEffect(void * jarg1) {
77808   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
77809
77810   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
77811   {
77812     try {
77813       delete arg1;
77814     } catch (std::out_of_range& e) {
77815       {
77816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77817       };
77818     } catch (std::exception& e) {
77819       {
77820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77821       };
77822     } catch (Dali::DaliException e) {
77823       {
77824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77825       };
77826     } catch (...) {
77827       {
77828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77829       };
77830     }
77831   }
77832
77833 }
77834
77835
77836 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_x_set(void * jarg1, int jarg2) {
77837   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
77838   Dali::Toolkit::ClampState arg2 ;
77839
77840   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
77841   arg2 = (Dali::Toolkit::ClampState)jarg2;
77842   if (arg1) (arg1)->x = arg2;
77843 }
77844
77845
77846 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_x_get(void * jarg1) {
77847   int jresult ;
77848   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
77849   Dali::Toolkit::ClampState result;
77850
77851   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
77852   result = (Dali::Toolkit::ClampState) ((arg1)->x);
77853   jresult = (int)result;
77854   return jresult;
77855 }
77856
77857
77858 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_y_set(void * jarg1, int jarg2) {
77859   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
77860   Dali::Toolkit::ClampState arg2 ;
77861
77862   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
77863   arg2 = (Dali::Toolkit::ClampState)jarg2;
77864   if (arg1) (arg1)->y = arg2;
77865 }
77866
77867
77868 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_y_get(void * jarg1) {
77869   int jresult ;
77870   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
77871   Dali::Toolkit::ClampState result;
77872
77873   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
77874   result = (Dali::Toolkit::ClampState) ((arg1)->y);
77875   jresult = (int)result;
77876   return jresult;
77877 }
77878
77879
77880 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ClampState2D() {
77881   void * jresult ;
77882   Dali::Toolkit::ClampState2D *result = 0 ;
77883
77884   {
77885     try {
77886       result = (Dali::Toolkit::ClampState2D *)new Dali::Toolkit::ClampState2D();
77887     } catch (std::out_of_range& e) {
77888       {
77889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77890       };
77891     } catch (std::exception& e) {
77892       {
77893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77894       };
77895     } catch (Dali::DaliException e) {
77896       {
77897         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77898       };
77899     } catch (...) {
77900       {
77901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77902       };
77903     }
77904   }
77905
77906   jresult = (void *)result;
77907   return jresult;
77908 }
77909
77910
77911 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ClampState2D(void * jarg1) {
77912   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
77913
77914   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
77915   {
77916     try {
77917       delete arg1;
77918     } catch (std::out_of_range& e) {
77919       {
77920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77921       };
77922     } catch (std::exception& e) {
77923       {
77924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77925       };
77926     } catch (Dali::DaliException e) {
77927       {
77928         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77929       };
77930     } catch (...) {
77931       {
77932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77933       };
77934     }
77935   }
77936
77937 }
77938
77939
77940 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_0(float jarg1, float jarg2, unsigned int jarg3) {
77941   void * jresult ;
77942   float arg1 ;
77943   float arg2 ;
77944   bool arg3 ;
77945   Dali::Toolkit::RulerDomain *result = 0 ;
77946
77947   arg1 = (float)jarg1;
77948   arg2 = (float)jarg2;
77949   arg3 = jarg3 ? true : false;
77950   {
77951     try {
77952       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2,arg3);
77953     } catch (std::out_of_range& e) {
77954       {
77955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77956       };
77957     } catch (std::exception& e) {
77958       {
77959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77960       };
77961     } catch (Dali::DaliException e) {
77962       {
77963         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77964       };
77965     } catch (...) {
77966       {
77967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77968       };
77969     }
77970   }
77971
77972   jresult = (void *)result;
77973   return jresult;
77974 }
77975
77976
77977 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_1(float jarg1, float jarg2) {
77978   void * jresult ;
77979   float arg1 ;
77980   float arg2 ;
77981   Dali::Toolkit::RulerDomain *result = 0 ;
77982
77983   arg1 = (float)jarg1;
77984   arg2 = (float)jarg2;
77985   {
77986     try {
77987       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2);
77988     } catch (std::out_of_range& e) {
77989       {
77990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77991       };
77992     } catch (std::exception& e) {
77993       {
77994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77995       };
77996     } catch (Dali::DaliException e) {
77997       {
77998         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77999       };
78000     } catch (...) {
78001       {
78002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78003       };
78004     }
78005   }
78006
78007   jresult = (void *)result;
78008   return jresult;
78009 }
78010
78011
78012 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_min_set(void * jarg1, float jarg2) {
78013   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78014   float arg2 ;
78015
78016   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78017   arg2 = (float)jarg2;
78018   if (arg1) (arg1)->min = arg2;
78019 }
78020
78021
78022 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_min_get(void * jarg1) {
78023   float jresult ;
78024   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78025   float result;
78026
78027   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78028   result = (float) ((arg1)->min);
78029   jresult = result;
78030   return jresult;
78031 }
78032
78033
78034 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_max_set(void * jarg1, float jarg2) {
78035   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78036   float arg2 ;
78037
78038   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78039   arg2 = (float)jarg2;
78040   if (arg1) (arg1)->max = arg2;
78041 }
78042
78043
78044 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_max_get(void * jarg1) {
78045   float jresult ;
78046   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78047   float result;
78048
78049   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78050   result = (float) ((arg1)->max);
78051   jresult = result;
78052   return jresult;
78053 }
78054
78055
78056 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_set(void * jarg1, unsigned int jarg2) {
78057   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78058   bool arg2 ;
78059
78060   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78061   arg2 = jarg2 ? true : false;
78062   if (arg1) (arg1)->enabled = arg2;
78063 }
78064
78065
78066 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_get(void * jarg1) {
78067   unsigned int jresult ;
78068   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78069   bool result;
78070
78071   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78072   result = (bool) ((arg1)->enabled);
78073   jresult = result;
78074   return jresult;
78075 }
78076
78077
78078 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
78079   float jresult ;
78080   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78081   float arg2 ;
78082   float arg3 ;
78083   float arg4 ;
78084   float result;
78085
78086   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78087   arg2 = (float)jarg2;
78088   arg3 = (float)jarg3;
78089   arg4 = (float)jarg4;
78090   {
78091     try {
78092       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4);
78093     } catch (std::out_of_range& e) {
78094       {
78095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78096       };
78097     } catch (std::exception& e) {
78098       {
78099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78100       };
78101     } catch (Dali::DaliException e) {
78102       {
78103         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78104       };
78105     } catch (...) {
78106       {
78107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78108       };
78109     }
78110   }
78111
78112   jresult = result;
78113   return jresult;
78114 }
78115
78116
78117 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
78118   float jresult ;
78119   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78120   float arg2 ;
78121   float arg3 ;
78122   float result;
78123
78124   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78125   arg2 = (float)jarg2;
78126   arg3 = (float)jarg3;
78127   {
78128     try {
78129       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3);
78130     } catch (std::out_of_range& e) {
78131       {
78132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78133       };
78134     } catch (std::exception& e) {
78135       {
78136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78137       };
78138     } catch (Dali::DaliException e) {
78139       {
78140         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78141       };
78142     } catch (...) {
78143       {
78144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78145       };
78146     }
78147   }
78148
78149   jresult = result;
78150   return jresult;
78151 }
78152
78153
78154 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_2(void * jarg1, float jarg2) {
78155   float jresult ;
78156   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78157   float arg2 ;
78158   float result;
78159
78160   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78161   arg2 = (float)jarg2;
78162   {
78163     try {
78164       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2);
78165     } catch (std::out_of_range& e) {
78166       {
78167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78168       };
78169     } catch (std::exception& e) {
78170       {
78171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78172       };
78173     } catch (Dali::DaliException e) {
78174       {
78175         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78176       };
78177     } catch (...) {
78178       {
78179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78180       };
78181     }
78182   }
78183
78184   jresult = result;
78185   return jresult;
78186 }
78187
78188
78189 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
78190   float jresult ;
78191   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78192   float arg2 ;
78193   float arg3 ;
78194   float arg4 ;
78195   Dali::Toolkit::ClampState *arg5 = 0 ;
78196   float result;
78197
78198   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78199   arg2 = (float)jarg2;
78200   arg3 = (float)jarg3;
78201   arg4 = (float)jarg4;
78202   arg5 = (Dali::Toolkit::ClampState *)jarg5;
78203   if (!arg5) {
78204     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
78205     return 0;
78206   }
78207   {
78208     try {
78209       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
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 float SWIGSTDCALL CSharp_Dali_RulerDomain_GetSize(void * jarg1) {
78235   float jresult ;
78236   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78237   float result;
78238
78239   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78240   {
78241     try {
78242       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->GetSize();
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 void SWIGSTDCALL CSharp_Dali_delete_RulerDomain(void * jarg1) {
78268   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78269
78270   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78271   {
78272     try {
78273       delete arg1;
78274     } catch (std::out_of_range& e) {
78275       {
78276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78277       };
78278     } catch (std::exception& e) {
78279       {
78280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78281       };
78282     } catch (Dali::DaliException e) {
78283       {
78284         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78285       };
78286     } catch (...) {
78287       {
78288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78289       };
78290     }
78291   }
78292
78293 }
78294
78295
78296 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
78297   float jresult ;
78298   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78299   float arg2 ;
78300   float arg3 ;
78301   float result;
78302
78303   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78304   arg2 = (float)jarg2;
78305   arg3 = (float)jarg3;
78306   {
78307     try {
78308       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2,arg3);
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 float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_1(void * jarg1, float jarg2) {
78334   float jresult ;
78335   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78336   float arg2 ;
78337   float result;
78338
78339   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78340   arg2 = (float)jarg2;
78341   {
78342     try {
78343       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2);
78344     } catch (std::out_of_range& e) {
78345       {
78346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78347       };
78348     } catch (std::exception& e) {
78349       {
78350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78351       };
78352     } catch (Dali::DaliException e) {
78353       {
78354         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78355       };
78356     } catch (...) {
78357       {
78358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78359       };
78360     }
78361   }
78362
78363   jresult = result;
78364   return jresult;
78365 }
78366
78367
78368 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
78369   float jresult ;
78370   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78371   unsigned int arg2 ;
78372   unsigned int *arg3 = 0 ;
78373   bool arg4 ;
78374   float result;
78375
78376   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78377   arg2 = (unsigned int)jarg2;
78378   arg3 = (unsigned int *)jarg3;
78379   arg4 = jarg4 ? true : false;
78380   {
78381     try {
78382       result = (float)((Dali::Toolkit::Ruler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
78383     } catch (std::out_of_range& e) {
78384       {
78385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78386       };
78387     } catch (std::exception& e) {
78388       {
78389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78390       };
78391     } catch (Dali::DaliException e) {
78392       {
78393         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78394       };
78395     } catch (...) {
78396       {
78397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78398       };
78399     }
78400   }
78401
78402   jresult = result;
78403   return jresult;
78404 }
78405
78406
78407 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
78408   unsigned int jresult ;
78409   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78410   float arg2 ;
78411   bool arg3 ;
78412   unsigned int result;
78413
78414   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78415   arg2 = (float)jarg2;
78416   arg3 = jarg3 ? true : false;
78417   {
78418     try {
78419       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetPageFromPosition(arg2,arg3);
78420     } catch (std::out_of_range& e) {
78421       {
78422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78423       };
78424     } catch (std::exception& e) {
78425       {
78426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78427       };
78428     } catch (Dali::DaliException e) {
78429       {
78430         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78431       };
78432     } catch (...) {
78433       {
78434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78435       };
78436     }
78437   }
78438
78439   jresult = result;
78440   return jresult;
78441 }
78442
78443
78444 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetTotalPages(void * jarg1) {
78445   unsigned int jresult ;
78446   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78447   unsigned int result;
78448
78449   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78450   {
78451     try {
78452       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetTotalPages();
78453     } catch (std::out_of_range& e) {
78454       {
78455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78456       };
78457     } catch (std::exception& e) {
78458       {
78459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78460       };
78461     } catch (Dali::DaliException e) {
78462       {
78463         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78464       };
78465     } catch (...) {
78466       {
78467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78468       };
78469     }
78470   }
78471
78472   jresult = result;
78473   return jresult;
78474 }
78475
78476
78477 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Ruler_GetType(void * jarg1) {
78478   int jresult ;
78479   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78480   Dali::Toolkit::Ruler::RulerType result;
78481
78482   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78483   {
78484     try {
78485       result = (Dali::Toolkit::Ruler::RulerType)((Dali::Toolkit::Ruler const *)arg1)->GetType();
78486     } catch (std::out_of_range& e) {
78487       {
78488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78489       };
78490     } catch (std::exception& e) {
78491       {
78492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78493       };
78494     } catch (Dali::DaliException e) {
78495       {
78496         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78497       };
78498     } catch (...) {
78499       {
78500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78501       };
78502     }
78503   }
78504
78505   jresult = (int)result;
78506   return jresult;
78507 }
78508
78509
78510 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_IsEnabled(void * jarg1) {
78511   unsigned int jresult ;
78512   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78513   bool result;
78514
78515   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78516   {
78517     try {
78518       result = (bool)((Dali::Toolkit::Ruler const *)arg1)->IsEnabled();
78519     } catch (std::out_of_range& e) {
78520       {
78521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78522       };
78523     } catch (std::exception& e) {
78524       {
78525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78526       };
78527     } catch (Dali::DaliException e) {
78528       {
78529         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78530       };
78531     } catch (...) {
78532       {
78533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78534       };
78535     }
78536   }
78537
78538   jresult = result;
78539   return jresult;
78540 }
78541
78542
78543 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Enable(void * jarg1) {
78544   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78545
78546   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78547   {
78548     try {
78549       (arg1)->Enable();
78550     } catch (std::out_of_range& e) {
78551       {
78552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78553       };
78554     } catch (std::exception& e) {
78555       {
78556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78557       };
78558     } catch (Dali::DaliException e) {
78559       {
78560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78561       };
78562     } catch (...) {
78563       {
78564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78565       };
78566     }
78567   }
78568
78569 }
78570
78571
78572 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Disable(void * jarg1) {
78573   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78574
78575   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78576   {
78577     try {
78578       (arg1)->Disable();
78579     } catch (std::out_of_range& e) {
78580       {
78581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78582       };
78583     } catch (std::exception& e) {
78584       {
78585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78586       };
78587     } catch (Dali::DaliException e) {
78588       {
78589         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78590       };
78591     } catch (...) {
78592       {
78593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78594       };
78595     }
78596   }
78597
78598 }
78599
78600
78601 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_SetDomain(void * jarg1, void * jarg2) {
78602   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78603   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
78604   Dali::Toolkit::RulerDomain *argp2 ;
78605
78606   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78607   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
78608   if (!argp2) {
78609     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
78610     return ;
78611   }
78612   arg2 = *argp2;
78613   {
78614     try {
78615       (arg1)->SetDomain(arg2);
78616     } catch (std::out_of_range& e) {
78617       {
78618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78619       };
78620     } catch (std::exception& e) {
78621       {
78622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78623       };
78624     } catch (Dali::DaliException e) {
78625       {
78626         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78627       };
78628     } catch (...) {
78629       {
78630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78631       };
78632     }
78633   }
78634
78635 }
78636
78637
78638 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Ruler_GetDomain(void * jarg1) {
78639   void * jresult ;
78640   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78641   Dali::Toolkit::RulerDomain *result = 0 ;
78642
78643   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78644   {
78645     try {
78646       result = (Dali::Toolkit::RulerDomain *) &((Dali::Toolkit::Ruler const *)arg1)->GetDomain();
78647     } catch (std::out_of_range& e) {
78648       {
78649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78650       };
78651     } catch (std::exception& e) {
78652       {
78653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78654       };
78655     } catch (Dali::DaliException e) {
78656       {
78657         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78658       };
78659     } catch (...) {
78660       {
78661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78662       };
78663     }
78664   }
78665
78666   jresult = (void *)result;
78667   return jresult;
78668 }
78669
78670
78671 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_DisableDomain(void * jarg1) {
78672   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78673
78674   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78675   {
78676     try {
78677       (arg1)->DisableDomain();
78678     } catch (std::out_of_range& e) {
78679       {
78680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78681       };
78682     } catch (std::exception& e) {
78683       {
78684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78685       };
78686     } catch (Dali::DaliException e) {
78687       {
78688         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78689       };
78690     } catch (...) {
78691       {
78692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78693       };
78694     }
78695   }
78696
78697 }
78698
78699
78700 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
78701   float jresult ;
78702   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78703   float arg2 ;
78704   float arg3 ;
78705   float arg4 ;
78706   float result;
78707
78708   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78709   arg2 = (float)jarg2;
78710   arg3 = (float)jarg3;
78711   arg4 = (float)jarg4;
78712   {
78713     try {
78714       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4);
78715     } catch (std::out_of_range& e) {
78716       {
78717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78718       };
78719     } catch (std::exception& e) {
78720       {
78721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78722       };
78723     } catch (Dali::DaliException e) {
78724       {
78725         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78726       };
78727     } catch (...) {
78728       {
78729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78730       };
78731     }
78732   }
78733
78734   jresult = result;
78735   return jresult;
78736 }
78737
78738
78739 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
78740   float jresult ;
78741   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78742   float arg2 ;
78743   float arg3 ;
78744   float result;
78745
78746   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78747   arg2 = (float)jarg2;
78748   arg3 = (float)jarg3;
78749   {
78750     try {
78751       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3);
78752     } catch (std::out_of_range& e) {
78753       {
78754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78755       };
78756     } catch (std::exception& e) {
78757       {
78758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78759       };
78760     } catch (Dali::DaliException e) {
78761       {
78762         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78763       };
78764     } catch (...) {
78765       {
78766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78767       };
78768     }
78769   }
78770
78771   jresult = result;
78772   return jresult;
78773 }
78774
78775
78776 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_2(void * jarg1, float jarg2) {
78777   float jresult ;
78778   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78779   float arg2 ;
78780   float result;
78781
78782   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78783   arg2 = (float)jarg2;
78784   {
78785     try {
78786       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2);
78787     } catch (std::out_of_range& e) {
78788       {
78789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78790       };
78791     } catch (std::exception& e) {
78792       {
78793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78794       };
78795     } catch (Dali::DaliException e) {
78796       {
78797         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78798       };
78799     } catch (...) {
78800       {
78801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78802       };
78803     }
78804   }
78805
78806   jresult = result;
78807   return jresult;
78808 }
78809
78810
78811 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
78812   float jresult ;
78813   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78814   float arg2 ;
78815   float arg3 ;
78816   float arg4 ;
78817   Dali::Toolkit::ClampState *arg5 = 0 ;
78818   float result;
78819
78820   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78821   arg2 = (float)jarg2;
78822   arg3 = (float)jarg3;
78823   arg4 = (float)jarg4;
78824   arg5 = (Dali::Toolkit::ClampState *)jarg5;
78825   if (!arg5) {
78826     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
78827     return 0;
78828   }
78829   {
78830     try {
78831       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
78832     } catch (std::out_of_range& e) {
78833       {
78834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78835       };
78836     } catch (std::exception& e) {
78837       {
78838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78839       };
78840     } catch (Dali::DaliException e) {
78841       {
78842         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78843       };
78844     } catch (...) {
78845       {
78846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78847       };
78848     }
78849   }
78850
78851   jresult = result;
78852   return jresult;
78853 }
78854
78855
78856 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
78857   float jresult ;
78858   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78859   float arg2 ;
78860   float arg3 ;
78861   float arg4 ;
78862   float arg5 ;
78863   float result;
78864
78865   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78866   arg2 = (float)jarg2;
78867   arg3 = (float)jarg3;
78868   arg4 = (float)jarg4;
78869   arg5 = (float)jarg5;
78870   {
78871     try {
78872       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
78873     } catch (std::out_of_range& e) {
78874       {
78875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78876       };
78877     } catch (std::exception& e) {
78878       {
78879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78880       };
78881     } catch (Dali::DaliException e) {
78882       {
78883         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78884       };
78885     } catch (...) {
78886       {
78887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78888       };
78889     }
78890   }
78891
78892   jresult = result;
78893   return jresult;
78894 }
78895
78896
78897 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
78898   float jresult ;
78899   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78900   float arg2 ;
78901   float arg3 ;
78902   float arg4 ;
78903   float result;
78904
78905   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78906   arg2 = (float)jarg2;
78907   arg3 = (float)jarg3;
78908   arg4 = (float)jarg4;
78909   {
78910     try {
78911       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4);
78912     } catch (std::out_of_range& e) {
78913       {
78914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78915       };
78916     } catch (std::exception& e) {
78917       {
78918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78919       };
78920     } catch (Dali::DaliException e) {
78921       {
78922         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78923       };
78924     } catch (...) {
78925       {
78926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78927       };
78928     }
78929   }
78930
78931   jresult = result;
78932   return jresult;
78933 }
78934
78935
78936 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
78937   float jresult ;
78938   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78939   float arg2 ;
78940   float arg3 ;
78941   float result;
78942
78943   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78944   arg2 = (float)jarg2;
78945   arg3 = (float)jarg3;
78946   {
78947     try {
78948       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3);
78949     } catch (std::out_of_range& e) {
78950       {
78951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78952       };
78953     } catch (std::exception& e) {
78954       {
78955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78956       };
78957     } catch (Dali::DaliException e) {
78958       {
78959         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78960       };
78961     } catch (...) {
78962       {
78963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78964       };
78965     }
78966   }
78967
78968   jresult = result;
78969   return jresult;
78970 }
78971
78972
78973 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
78974   float jresult ;
78975   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78976   float arg2 ;
78977   float result;
78978
78979   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78980   arg2 = (float)jarg2;
78981   {
78982     try {
78983       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2);
78984     } catch (std::out_of_range& e) {
78985       {
78986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78987       };
78988     } catch (std::exception& e) {
78989       {
78990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78991       };
78992     } catch (Dali::DaliException e) {
78993       {
78994         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78995       };
78996     } catch (...) {
78997       {
78998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78999       };
79000     }
79001   }
79002
79003   jresult = result;
79004   return jresult;
79005 }
79006
79007
79008 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
79009   float jresult ;
79010   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
79011   float arg2 ;
79012   float arg3 ;
79013   float arg4 ;
79014   float arg5 ;
79015   Dali::Toolkit::ClampState *arg6 = 0 ;
79016   float result;
79017
79018   arg1 = (Dali::Toolkit::Ruler *)jarg1;
79019   arg2 = (float)jarg2;
79020   arg3 = (float)jarg3;
79021   arg4 = (float)jarg4;
79022   arg5 = (float)jarg5;
79023   arg6 = (Dali::Toolkit::ClampState *)jarg6;
79024   if (!arg6) {
79025     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
79026     return 0;
79027   }
79028   {
79029     try {
79030       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
79031     } catch (std::out_of_range& e) {
79032       {
79033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79034       };
79035     } catch (std::exception& e) {
79036       {
79037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79038       };
79039     } catch (Dali::DaliException e) {
79040       {
79041         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79042       };
79043     } catch (...) {
79044       {
79045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79046       };
79047     }
79048   }
79049
79050   jresult = result;
79051   return jresult;
79052 }
79053
79054
79055 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DefaultRuler() {
79056   void * jresult ;
79057   Dali::Toolkit::DefaultRuler *result = 0 ;
79058
79059   {
79060     try {
79061       result = (Dali::Toolkit::DefaultRuler *)new Dali::Toolkit::DefaultRuler();
79062     } catch (std::out_of_range& e) {
79063       {
79064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79065       };
79066     } catch (std::exception& e) {
79067       {
79068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79069       };
79070     } catch (Dali::DaliException e) {
79071       {
79072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79073       };
79074     } catch (...) {
79075       {
79076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79077       };
79078     }
79079   }
79080
79081   jresult = (void *)result;
79082   return jresult;
79083 }
79084
79085
79086 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_Snap(void * jarg1, float jarg2, float jarg3) {
79087   float jresult ;
79088   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
79089   float arg2 ;
79090   float arg3 ;
79091   float result;
79092
79093   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
79094   arg2 = (float)jarg2;
79095   arg3 = (float)jarg3;
79096   {
79097     try {
79098       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->Snap(arg2,arg3);
79099     } catch (std::out_of_range& e) {
79100       {
79101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79102       };
79103     } catch (std::exception& e) {
79104       {
79105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79106       };
79107     } catch (Dali::DaliException e) {
79108       {
79109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79110       };
79111     } catch (...) {
79112       {
79113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79114       };
79115     }
79116   }
79117
79118   jresult = result;
79119   return jresult;
79120 }
79121
79122
79123 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
79124   float jresult ;
79125   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
79126   unsigned int arg2 ;
79127   unsigned int *arg3 = 0 ;
79128   bool arg4 ;
79129   float result;
79130
79131   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
79132   arg2 = (unsigned int)jarg2;
79133   arg3 = (unsigned int *)jarg3;
79134   arg4 = jarg4 ? true : false;
79135   {
79136     try {
79137       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
79138     } catch (std::out_of_range& e) {
79139       {
79140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79141       };
79142     } catch (std::exception& e) {
79143       {
79144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79145       };
79146     } catch (Dali::DaliException e) {
79147       {
79148         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79149       };
79150     } catch (...) {
79151       {
79152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79153       };
79154     }
79155   }
79156
79157   jresult = result;
79158   return jresult;
79159 }
79160
79161
79162 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
79163   unsigned int jresult ;
79164   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
79165   float arg2 ;
79166   bool arg3 ;
79167   unsigned int result;
79168
79169   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
79170   arg2 = (float)jarg2;
79171   arg3 = jarg3 ? true : false;
79172   {
79173     try {
79174       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
79175     } catch (std::out_of_range& e) {
79176       {
79177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79178       };
79179     } catch (std::exception& e) {
79180       {
79181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79182       };
79183     } catch (Dali::DaliException e) {
79184       {
79185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79186       };
79187     } catch (...) {
79188       {
79189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79190       };
79191     }
79192   }
79193
79194   jresult = result;
79195   return jresult;
79196 }
79197
79198
79199 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetTotalPages(void * jarg1) {
79200   unsigned int jresult ;
79201   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
79202   unsigned int result;
79203
79204   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
79205   {
79206     try {
79207       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetTotalPages();
79208     } catch (std::out_of_range& e) {
79209       {
79210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79211       };
79212     } catch (std::exception& e) {
79213       {
79214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79215       };
79216     } catch (Dali::DaliException e) {
79217       {
79218         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79219       };
79220     } catch (...) {
79221       {
79222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79223       };
79224     }
79225   }
79226
79227   jresult = result;
79228   return jresult;
79229 }
79230
79231
79232 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DefaultRuler(void * jarg1) {
79233   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
79234
79235   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
79236   {
79237     try {
79238       delete arg1;
79239     } catch (std::out_of_range& e) {
79240       {
79241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79242       };
79243     } catch (std::exception& e) {
79244       {
79245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79246       };
79247     } catch (Dali::DaliException e) {
79248       {
79249         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79250       };
79251     } catch (...) {
79252       {
79253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79254       };
79255     }
79256   }
79257
79258 }
79259
79260
79261 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_0(float jarg1) {
79262   void * jresult ;
79263   float arg1 ;
79264   Dali::Toolkit::FixedRuler *result = 0 ;
79265
79266   arg1 = (float)jarg1;
79267   {
79268     try {
79269       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler(arg1);
79270     } catch (std::out_of_range& e) {
79271       {
79272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79273       };
79274     } catch (std::exception& e) {
79275       {
79276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79277       };
79278     } catch (Dali::DaliException e) {
79279       {
79280         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79281       };
79282     } catch (...) {
79283       {
79284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79285       };
79286     }
79287   }
79288
79289   jresult = (void *)result;
79290   return jresult;
79291 }
79292
79293
79294 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_1() {
79295   void * jresult ;
79296   Dali::Toolkit::FixedRuler *result = 0 ;
79297
79298   {
79299     try {
79300       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler();
79301     } catch (std::out_of_range& e) {
79302       {
79303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79304       };
79305     } catch (std::exception& e) {
79306       {
79307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79308       };
79309     } catch (Dali::DaliException e) {
79310       {
79311         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79312       };
79313     } catch (...) {
79314       {
79315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79316       };
79317     }
79318   }
79319
79320   jresult = (void *)result;
79321   return jresult;
79322 }
79323
79324
79325 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_Snap(void * jarg1, float jarg2, float jarg3) {
79326   float jresult ;
79327   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
79328   float arg2 ;
79329   float arg3 ;
79330   float result;
79331
79332   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
79333   arg2 = (float)jarg2;
79334   arg3 = (float)jarg3;
79335   {
79336     try {
79337       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->Snap(arg2,arg3);
79338     } catch (std::out_of_range& e) {
79339       {
79340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79341       };
79342     } catch (std::exception& e) {
79343       {
79344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79345       };
79346     } catch (Dali::DaliException e) {
79347       {
79348         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79349       };
79350     } catch (...) {
79351       {
79352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79353       };
79354     }
79355   }
79356
79357   jresult = result;
79358   return jresult;
79359 }
79360
79361
79362 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
79363   float jresult ;
79364   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
79365   unsigned int arg2 ;
79366   unsigned int *arg3 = 0 ;
79367   bool arg4 ;
79368   float result;
79369
79370   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
79371   arg2 = (unsigned int)jarg2;
79372   arg3 = (unsigned int *)jarg3;
79373   arg4 = jarg4 ? true : false;
79374   {
79375     try {
79376       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
79377     } catch (std::out_of_range& e) {
79378       {
79379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79380       };
79381     } catch (std::exception& e) {
79382       {
79383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79384       };
79385     } catch (Dali::DaliException e) {
79386       {
79387         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79388       };
79389     } catch (...) {
79390       {
79391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79392       };
79393     }
79394   }
79395
79396   jresult = result;
79397   return jresult;
79398 }
79399
79400
79401 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
79402   unsigned int jresult ;
79403   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
79404   float arg2 ;
79405   bool arg3 ;
79406   unsigned int result;
79407
79408   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
79409   arg2 = (float)jarg2;
79410   arg3 = jarg3 ? true : false;
79411   {
79412     try {
79413       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
79414     } catch (std::out_of_range& e) {
79415       {
79416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79417       };
79418     } catch (std::exception& e) {
79419       {
79420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79421       };
79422     } catch (Dali::DaliException e) {
79423       {
79424         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79425       };
79426     } catch (...) {
79427       {
79428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79429       };
79430     }
79431   }
79432
79433   jresult = result;
79434   return jresult;
79435 }
79436
79437
79438 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetTotalPages(void * jarg1) {
79439   unsigned int jresult ;
79440   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
79441   unsigned int result;
79442
79443   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
79444   {
79445     try {
79446       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetTotalPages();
79447     } catch (std::out_of_range& e) {
79448       {
79449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79450       };
79451     } catch (std::exception& e) {
79452       {
79453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79454       };
79455     } catch (Dali::DaliException e) {
79456       {
79457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79458       };
79459     } catch (...) {
79460       {
79461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79462       };
79463     }
79464   }
79465
79466   jresult = result;
79467   return jresult;
79468 }
79469
79470
79471 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FixedRuler(void * jarg1) {
79472   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
79473
79474   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
79475   {
79476     try {
79477       delete arg1;
79478     } catch (std::out_of_range& e) {
79479       {
79480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79481       };
79482     } catch (std::exception& e) {
79483       {
79484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79485       };
79486     } catch (Dali::DaliException e) {
79487       {
79488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79489       };
79490     } catch (...) {
79491       {
79492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79493       };
79494     }
79495   }
79496
79497 }
79498
79499
79500 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_set(void * jarg1, void * jarg2) {
79501   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79502   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
79503
79504   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79505   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
79506   if (arg1) (arg1)->scale = *arg2;
79507 }
79508
79509
79510 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_get(void * jarg1) {
79511   void * jresult ;
79512   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79513   Dali::Toolkit::ClampState2D *result = 0 ;
79514
79515   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79516   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->scale);
79517   jresult = (void *)result;
79518   return jresult;
79519 }
79520
79521
79522 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_set(void * jarg1, void * jarg2) {
79523   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79524   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
79525
79526   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79527   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
79528   if (arg1) (arg1)->position = *arg2;
79529 }
79530
79531
79532 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_get(void * jarg1) {
79533   void * jresult ;
79534   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79535   Dali::Toolkit::ClampState2D *result = 0 ;
79536
79537   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79538   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->position);
79539   jresult = (void *)result;
79540   return jresult;
79541 }
79542
79543
79544 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_set(void * jarg1, int jarg2) {
79545   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79546   Dali::Toolkit::ClampState arg2 ;
79547
79548   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79549   arg2 = (Dali::Toolkit::ClampState)jarg2;
79550   if (arg1) (arg1)->rotation = arg2;
79551 }
79552
79553
79554 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_get(void * jarg1) {
79555   int jresult ;
79556   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79557   Dali::Toolkit::ClampState result;
79558
79559   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79560   result = (Dali::Toolkit::ClampState) ((arg1)->rotation);
79561   jresult = (int)result;
79562   return jresult;
79563 }
79564
79565
79566 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_ClampEvent() {
79567   void * jresult ;
79568   Dali::Toolkit::ScrollView::ClampEvent *result = 0 ;
79569
79570   {
79571     try {
79572       result = (Dali::Toolkit::ScrollView::ClampEvent *)new Dali::Toolkit::ScrollView::ClampEvent();
79573     } catch (std::out_of_range& e) {
79574       {
79575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79576       };
79577     } catch (std::exception& e) {
79578       {
79579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79580       };
79581     } catch (Dali::DaliException e) {
79582       {
79583         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79584       };
79585     } catch (...) {
79586       {
79587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79588       };
79589     }
79590   }
79591
79592   jresult = (void *)result;
79593   return jresult;
79594 }
79595
79596
79597 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_ClampEvent(void * jarg1) {
79598   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79599
79600   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79601   {
79602     try {
79603       delete arg1;
79604     } catch (std::out_of_range& e) {
79605       {
79606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79607       };
79608     } catch (std::exception& e) {
79609       {
79610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79611       };
79612     } catch (Dali::DaliException e) {
79613       {
79614         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79615       };
79616     } catch (...) {
79617       {
79618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79619       };
79620     }
79621   }
79622
79623 }
79624
79625
79626 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_set(void * jarg1, int jarg2) {
79627   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79628   Dali::Toolkit::SnapType arg2 ;
79629
79630   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79631   arg2 = (Dali::Toolkit::SnapType)jarg2;
79632   if (arg1) (arg1)->type = arg2;
79633 }
79634
79635
79636 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_get(void * jarg1) {
79637   int jresult ;
79638   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79639   Dali::Toolkit::SnapType result;
79640
79641   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79642   result = (Dali::Toolkit::SnapType) ((arg1)->type);
79643   jresult = (int)result;
79644   return jresult;
79645 }
79646
79647
79648 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_set(void * jarg1, void * jarg2) {
79649   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79650   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
79651
79652   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79653   arg2 = (Dali::Vector2 *)jarg2;
79654   if (arg1) (arg1)->position = *arg2;
79655 }
79656
79657
79658 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_get(void * jarg1) {
79659   void * jresult ;
79660   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79661   Dali::Vector2 *result = 0 ;
79662
79663   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79664   result = (Dali::Vector2 *)& ((arg1)->position);
79665   jresult = (void *)result;
79666   return jresult;
79667 }
79668
79669
79670 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_set(void * jarg1, float jarg2) {
79671   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79672   float arg2 ;
79673
79674   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79675   arg2 = (float)jarg2;
79676   if (arg1) (arg1)->duration = arg2;
79677 }
79678
79679
79680 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_get(void * jarg1) {
79681   float jresult ;
79682   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79683   float result;
79684
79685   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79686   result = (float) ((arg1)->duration);
79687   jresult = result;
79688   return jresult;
79689 }
79690
79691
79692 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_SnapEvent() {
79693   void * jresult ;
79694   Dali::Toolkit::ScrollView::SnapEvent *result = 0 ;
79695
79696   {
79697     try {
79698       result = (Dali::Toolkit::ScrollView::SnapEvent *)new Dali::Toolkit::ScrollView::SnapEvent();
79699     } catch (std::out_of_range& e) {
79700       {
79701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79702       };
79703     } catch (std::exception& e) {
79704       {
79705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79706       };
79707     } catch (Dali::DaliException e) {
79708       {
79709         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79710       };
79711     } catch (...) {
79712       {
79713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79714       };
79715     }
79716   }
79717
79718   jresult = (void *)result;
79719   return jresult;
79720 }
79721
79722
79723 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_SnapEvent(void * jarg1) {
79724   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79725
79726   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79727   {
79728     try {
79729       delete arg1;
79730     } catch (std::out_of_range& e) {
79731       {
79732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79733       };
79734     } catch (std::exception& e) {
79735       {
79736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79737       };
79738     } catch (Dali::DaliException e) {
79739       {
79740         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79741       };
79742     } catch (...) {
79743       {
79744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79745       };
79746     }
79747   }
79748
79749 }
79750
79751
79752 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_ENABLED_get() {
79753   int jresult ;
79754   int result;
79755
79756   result = (int)Dali::Toolkit::ScrollView::Property::WRAP_ENABLED;
79757   jresult = (int)result;
79758   return jresult;
79759 }
79760
79761
79762 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_ENABLED_get() {
79763   int jresult ;
79764   int result;
79765
79766   result = (int)Dali::Toolkit::ScrollView::Property::PANNING_ENABLED;
79767   jresult = (int)result;
79768   return jresult;
79769 }
79770
79771
79772 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_AXIS_AUTO_LOCK_ENABLED_get() {
79773   int jresult ;
79774   int result;
79775
79776   result = (int)Dali::Toolkit::ScrollView::Property::AXIS_AUTO_LOCK_ENABLED;
79777   jresult = (int)result;
79778   return jresult;
79779 }
79780
79781
79782 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
79783   int jresult ;
79784   int result;
79785
79786   result = (int)Dali::Toolkit::ScrollView::Property::WHEEL_SCROLL_DISTANCE_STEP;
79787   jresult = (int)result;
79788   return jresult;
79789 }
79790
79791
79792 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_MODE_get() {
79793   int jresult ;
79794   int result;
79795
79796   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_MODE;
79797   jresult = (int)result;
79798   return jresult;
79799 }
79800
79801 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_get() {
79802   int jresult ;
79803   int result;
79804
79805   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION;
79806   jresult = (int)result;
79807   return jresult;
79808 }
79809
79810
79811 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_get() {
79812   int jresult ;
79813   int result;
79814
79815   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION;
79816   jresult = (int)result;
79817   return jresult;
79818 }
79819
79820
79821 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_X_get() {
79822   int jresult ;
79823   int result;
79824
79825   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_X;
79826   jresult = (int)result;
79827   return jresult;
79828 }
79829
79830
79831 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_Y_get() {
79832   int jresult ;
79833   int result;
79834
79835   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_Y;
79836   jresult = (int)result;
79837   return jresult;
79838 }
79839
79840
79841 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_get() {
79842   int jresult ;
79843   int result;
79844
79845   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX;
79846   jresult = (int)result;
79847   return jresult;
79848 }
79849
79850
79851 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_X_get() {
79852   int jresult ;
79853   int result;
79854
79855   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_X;
79856   jresult = (int)result;
79857   return jresult;
79858 }
79859
79860
79861 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_Y_get() {
79862   int jresult ;
79863   int result;
79864
79865   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_Y;
79866   jresult = (int)result;
79867   return jresult;
79868 }
79869
79870
79871 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_X_get() {
79872   int jresult ;
79873   int result;
79874
79875   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_X;
79876   jresult = (int)result;
79877   return jresult;
79878 }
79879
79880
79881 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_Y_get() {
79882   int jresult ;
79883   int result;
79884
79885   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_Y;
79886   jresult = (int)result;
79887   return jresult;
79888 }
79889
79890
79891 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_get() {
79892   int jresult ;
79893   int result;
79894
79895   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL;
79896   jresult = (int)result;
79897   return jresult;
79898 }
79899
79900
79901 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_X_get() {
79902   int jresult ;
79903   int result;
79904
79905   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_X;
79906   jresult = (int)result;
79907   return jresult;
79908 }
79909
79910
79911 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_Y_get() {
79912   int jresult ;
79913   int result;
79914
79915   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_Y;
79916   jresult = (int)result;
79917   return jresult;
79918 }
79919
79920
79921 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_get() {
79922   int jresult ;
79923   int result;
79924
79925   result = (int)Dali::Toolkit::ScrollView::Property::WRAP;
79926   jresult = (int)result;
79927   return jresult;
79928 }
79929
79930
79931 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_get() {
79932   int jresult ;
79933   int result;
79934
79935   result = (int)Dali::Toolkit::ScrollView::Property::PANNING;
79936   jresult = (int)result;
79937   return jresult;
79938 }
79939
79940
79941 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLLING_get() {
79942   int jresult ;
79943   int result;
79944
79945   result = (int)Dali::Toolkit::ScrollView::Property::SCROLLING;
79946   jresult = (int)result;
79947   return jresult;
79948 }
79949
79950
79951 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_get() {
79952   int jresult ;
79953   int result;
79954
79955   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE;
79956   jresult = (int)result;
79957   return jresult;
79958 }
79959
79960
79961 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_X_get() {
79962   int jresult ;
79963   int result;
79964
79965   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_X;
79966   jresult = (int)result;
79967   return jresult;
79968 }
79969
79970
79971 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_Y_get() {
79972   int jresult ;
79973   int result;
79974
79975   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_Y;
79976   jresult = (int)result;
79977   return jresult;
79978 }
79979
79980
79981 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_OFFSET_get() {
79982   int jresult ;
79983   int result;
79984
79985   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_OFFSET;
79986   jresult = (int)result;
79987   return jresult;
79988 }
79989
79990
79991 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_DELTA_get() {
79992   int jresult ;
79993   int result;
79994
79995   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION_DELTA;
79996   jresult = (int)result;
79997   return jresult;
79998 }
79999
80000
80001 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_START_PAGE_POSITION_get() {
80002   int jresult ;
80003   int result;
80004
80005   result = (int)Dali::Toolkit::ScrollView::Property::START_PAGE_POSITION;
80006   jresult = (int)result;
80007   return jresult;
80008 }
80009
80010
80011 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_Property() {
80012   void * jresult ;
80013   Dali::Toolkit::ScrollView::Property *result = 0 ;
80014
80015   {
80016     try {
80017       result = (Dali::Toolkit::ScrollView::Property *)new Dali::Toolkit::ScrollView::Property();
80018     } catch (std::out_of_range& e) {
80019       {
80020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80021       };
80022     } catch (std::exception& e) {
80023       {
80024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80025       };
80026     } catch (Dali::DaliException e) {
80027       {
80028         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80029       };
80030     } catch (...) {
80031       {
80032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80033       };
80034     }
80035   }
80036
80037   jresult = (void *)result;
80038   return jresult;
80039 }
80040
80041
80042 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_Property(void * jarg1) {
80043   Dali::Toolkit::ScrollView::Property *arg1 = (Dali::Toolkit::ScrollView::Property *) 0 ;
80044
80045   arg1 = (Dali::Toolkit::ScrollView::Property *)jarg1;
80046   {
80047     try {
80048       delete arg1;
80049     } catch (std::out_of_range& e) {
80050       {
80051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80052       };
80053     } catch (std::exception& e) {
80054       {
80055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80056       };
80057     } catch (Dali::DaliException e) {
80058       {
80059         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80060       };
80061     } catch (...) {
80062       {
80063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80064       };
80065     }
80066   }
80067
80068 }
80069
80070
80071 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_0() {
80072   void * jresult ;
80073   Dali::Toolkit::ScrollView *result = 0 ;
80074
80075   {
80076     try {
80077       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView();
80078     } catch (std::out_of_range& e) {
80079       {
80080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80081       };
80082     } catch (std::exception& e) {
80083       {
80084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80085       };
80086     } catch (Dali::DaliException e) {
80087       {
80088         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80089       };
80090     } catch (...) {
80091       {
80092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80093       };
80094     }
80095   }
80096
80097   jresult = (void *)result;
80098   return jresult;
80099 }
80100
80101
80102 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_1(void * jarg1) {
80103   void * jresult ;
80104   Dali::Toolkit::ScrollView *arg1 = 0 ;
80105   Dali::Toolkit::ScrollView *result = 0 ;
80106
80107   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80108   if (!arg1) {
80109     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
80110     return 0;
80111   }
80112   {
80113     try {
80114       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView((Dali::Toolkit::ScrollView const &)*arg1);
80115     } catch (std::out_of_range& e) {
80116       {
80117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80118       };
80119     } catch (std::exception& e) {
80120       {
80121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80122       };
80123     } catch (Dali::DaliException e) {
80124       {
80125         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80126       };
80127     } catch (...) {
80128       {
80129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80130       };
80131     }
80132   }
80133
80134   jresult = (void *)result;
80135   return jresult;
80136 }
80137
80138
80139 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_Assign(void * jarg1, void * jarg2) {
80140   void * jresult ;
80141   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80142   Dali::Toolkit::ScrollView *arg2 = 0 ;
80143   Dali::Toolkit::ScrollView *result = 0 ;
80144
80145   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80146   arg2 = (Dali::Toolkit::ScrollView *)jarg2;
80147   if (!arg2) {
80148     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
80149     return 0;
80150   }
80151   {
80152     try {
80153       result = (Dali::Toolkit::ScrollView *) &(arg1)->operator =((Dali::Toolkit::ScrollView const &)*arg2);
80154     } catch (std::out_of_range& e) {
80155       {
80156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80157       };
80158     } catch (std::exception& e) {
80159       {
80160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80161       };
80162     } catch (Dali::DaliException e) {
80163       {
80164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80165       };
80166     } catch (...) {
80167       {
80168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80169       };
80170     }
80171   }
80172
80173   jresult = (void *)result;
80174   return jresult;
80175 }
80176
80177
80178 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView(void * jarg1) {
80179   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80180
80181   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80182   {
80183     try {
80184       delete arg1;
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 void * SWIGSTDCALL CSharp_Dali_ScrollView_New() {
80208   void * jresult ;
80209   Dali::Toolkit::ScrollView result;
80210
80211   {
80212     try {
80213       result = Dali::Toolkit::ScrollView::New();
80214     } catch (std::out_of_range& e) {
80215       {
80216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80217       };
80218     } catch (std::exception& e) {
80219       {
80220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80221       };
80222     } catch (Dali::DaliException e) {
80223       {
80224         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80225       };
80226     } catch (...) {
80227       {
80228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80229       };
80230     }
80231   }
80232
80233   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
80234   return jresult;
80235 }
80236
80237
80238 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_DownCast(void * jarg1) {
80239   void * jresult ;
80240   Dali::BaseHandle arg1 ;
80241   Dali::BaseHandle *argp1 ;
80242   Dali::Toolkit::ScrollView result;
80243
80244   argp1 = (Dali::BaseHandle *)jarg1;
80245   if (!argp1) {
80246     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
80247     return 0;
80248   }
80249   arg1 = *argp1;
80250   {
80251     try {
80252       result = Dali::Toolkit::ScrollView::DownCast(arg1);
80253     } catch (std::out_of_range& e) {
80254       {
80255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80256       };
80257     } catch (std::exception& e) {
80258       {
80259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80260       };
80261     } catch (Dali::DaliException e) {
80262       {
80263         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80264       };
80265     } catch (...) {
80266       {
80267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80268       };
80269     }
80270   }
80271
80272   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
80273   return jresult;
80274 }
80275
80276
80277 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapAlphaFunction(void * jarg1) {
80278   void * jresult ;
80279   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80280   Dali::AlphaFunction result;
80281
80282   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80283   {
80284     try {
80285       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapAlphaFunction();
80286     } catch (std::out_of_range& e) {
80287       {
80288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80289       };
80290     } catch (std::exception& e) {
80291       {
80292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80293       };
80294     } catch (Dali::DaliException e) {
80295       {
80296         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80297       };
80298     } catch (...) {
80299       {
80300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80301       };
80302     }
80303   }
80304
80305   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
80306   return jresult;
80307 }
80308
80309
80310 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapAlphaFunction(void * jarg1, void * jarg2) {
80311   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80312   Dali::AlphaFunction arg2 ;
80313   Dali::AlphaFunction *argp2 ;
80314
80315   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80316   argp2 = (Dali::AlphaFunction *)jarg2;
80317   if (!argp2) {
80318     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
80319     return ;
80320   }
80321   arg2 = *argp2;
80322   {
80323     try {
80324       (arg1)->SetScrollSnapAlphaFunction(arg2);
80325     } catch (std::out_of_range& e) {
80326       {
80327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80328       };
80329     } catch (std::exception& e) {
80330       {
80331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80332       };
80333     } catch (Dali::DaliException e) {
80334       {
80335         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80336       };
80337     } catch (...) {
80338       {
80339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80340       };
80341     }
80342   }
80343
80344 }
80345
80346
80347 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickAlphaFunction(void * jarg1) {
80348   void * jresult ;
80349   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80350   Dali::AlphaFunction result;
80351
80352   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80353   {
80354     try {
80355       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickAlphaFunction();
80356     } catch (std::out_of_range& e) {
80357       {
80358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80359       };
80360     } catch (std::exception& e) {
80361       {
80362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80363       };
80364     } catch (Dali::DaliException e) {
80365       {
80366         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80367       };
80368     } catch (...) {
80369       {
80370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80371       };
80372     }
80373   }
80374
80375   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
80376   return jresult;
80377 }
80378
80379
80380 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickAlphaFunction(void * jarg1, void * jarg2) {
80381   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80382   Dali::AlphaFunction arg2 ;
80383   Dali::AlphaFunction *argp2 ;
80384
80385   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80386   argp2 = (Dali::AlphaFunction *)jarg2;
80387   if (!argp2) {
80388     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
80389     return ;
80390   }
80391   arg2 = *argp2;
80392   {
80393     try {
80394       (arg1)->SetScrollFlickAlphaFunction(arg2);
80395     } catch (std::out_of_range& e) {
80396       {
80397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80398       };
80399     } catch (std::exception& e) {
80400       {
80401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80402       };
80403     } catch (Dali::DaliException e) {
80404       {
80405         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80406       };
80407     } catch (...) {
80408       {
80409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80410       };
80411     }
80412   }
80413
80414 }
80415
80416
80417 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapDuration(void * jarg1) {
80418   float jresult ;
80419   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80420   float result;
80421
80422   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80423   {
80424     try {
80425       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapDuration();
80426     } catch (std::out_of_range& e) {
80427       {
80428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80429       };
80430     } catch (std::exception& e) {
80431       {
80432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80433       };
80434     } catch (Dali::DaliException e) {
80435       {
80436         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80437       };
80438     } catch (...) {
80439       {
80440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80441       };
80442     }
80443   }
80444
80445   jresult = result;
80446   return jresult;
80447 }
80448
80449
80450 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapDuration(void * jarg1, float jarg2) {
80451   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80452   float arg2 ;
80453
80454   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80455   arg2 = (float)jarg2;
80456   {
80457     try {
80458       (arg1)->SetScrollSnapDuration(arg2);
80459     } catch (std::out_of_range& e) {
80460       {
80461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80462       };
80463     } catch (std::exception& e) {
80464       {
80465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80466       };
80467     } catch (Dali::DaliException e) {
80468       {
80469         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80470       };
80471     } catch (...) {
80472       {
80473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80474       };
80475     }
80476   }
80477
80478 }
80479
80480
80481 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickDuration(void * jarg1) {
80482   float jresult ;
80483   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80484   float result;
80485
80486   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80487   {
80488     try {
80489       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickDuration();
80490     } catch (std::out_of_range& e) {
80491       {
80492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80493       };
80494     } catch (std::exception& e) {
80495       {
80496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80497       };
80498     } catch (Dali::DaliException e) {
80499       {
80500         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80501       };
80502     } catch (...) {
80503       {
80504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80505       };
80506     }
80507   }
80508
80509   jresult = result;
80510   return jresult;
80511 }
80512
80513
80514 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickDuration(void * jarg1, float jarg2) {
80515   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80516   float arg2 ;
80517
80518   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80519   arg2 = (float)jarg2;
80520   {
80521     try {
80522       (arg1)->SetScrollFlickDuration(arg2);
80523     } catch (std::out_of_range& e) {
80524       {
80525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80526       };
80527     } catch (std::exception& e) {
80528       {
80529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80530       };
80531     } catch (Dali::DaliException e) {
80532       {
80533         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80534       };
80535     } catch (...) {
80536       {
80537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80538       };
80539     }
80540   }
80541
80542 }
80543
80544
80545 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerX(void * jarg1, void * jarg2) {
80546   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80547   Dali::Toolkit::RulerPtr arg2 ;
80548   Dali::Toolkit::RulerPtr *argp2 ;
80549
80550   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80551   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
80552   if (!argp2) {
80553     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
80554     return ;
80555   }
80556   arg2 = *argp2;
80557   {
80558     try {
80559       (arg1)->SetRulerX(arg2);
80560     } catch (std::out_of_range& e) {
80561       {
80562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80563       };
80564     } catch (std::exception& e) {
80565       {
80566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80567       };
80568     } catch (Dali::DaliException e) {
80569       {
80570         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80571       };
80572     } catch (...) {
80573       {
80574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80575       };
80576     }
80577   }
80578
80579 }
80580
80581
80582 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerY(void * jarg1, void * jarg2) {
80583   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80584   Dali::Toolkit::RulerPtr arg2 ;
80585   Dali::Toolkit::RulerPtr *argp2 ;
80586
80587   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80588   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
80589   if (!argp2) {
80590     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
80591     return ;
80592   }
80593   arg2 = *argp2;
80594   {
80595     try {
80596       (arg1)->SetRulerY(arg2);
80597     } catch (std::out_of_range& e) {
80598       {
80599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80600       };
80601     } catch (std::exception& e) {
80602       {
80603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80604       };
80605     } catch (Dali::DaliException e) {
80606       {
80607         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80608       };
80609     } catch (...) {
80610       {
80611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80612       };
80613     }
80614   }
80615
80616 }
80617
80618
80619 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSensitive(void * jarg1, unsigned int jarg2) {
80620   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80621   bool arg2 ;
80622
80623   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80624   arg2 = jarg2 ? true : false;
80625   {
80626     try {
80627       (arg1)->SetScrollSensitive(arg2);
80628     } catch (std::out_of_range& e) {
80629       {
80630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80631       };
80632     } catch (std::exception& e) {
80633       {
80634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80635       };
80636     } catch (Dali::DaliException e) {
80637       {
80638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80639       };
80640     } catch (...) {
80641       {
80642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80643       };
80644     }
80645   }
80646
80647 }
80648
80649
80650 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxOvershoot(void * jarg1, float jarg2, float jarg3) {
80651   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80652   float arg2 ;
80653   float arg3 ;
80654
80655   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80656   arg2 = (float)jarg2;
80657   arg3 = (float)jarg3;
80658   {
80659     try {
80660       (arg1)->SetMaxOvershoot(arg2,arg3);
80661     } catch (std::out_of_range& e) {
80662       {
80663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80664       };
80665     } catch (std::exception& e) {
80666       {
80667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80668       };
80669     } catch (Dali::DaliException e) {
80670       {
80671         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80672       };
80673     } catch (...) {
80674       {
80675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80676       };
80677     }
80678   }
80679
80680 }
80681
80682
80683 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootAlphaFunction(void * jarg1, void * jarg2) {
80684   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80685   Dali::AlphaFunction arg2 ;
80686   Dali::AlphaFunction *argp2 ;
80687
80688   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80689   argp2 = (Dali::AlphaFunction *)jarg2;
80690   if (!argp2) {
80691     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
80692     return ;
80693   }
80694   arg2 = *argp2;
80695   {
80696     try {
80697       (arg1)->SetSnapOvershootAlphaFunction(arg2);
80698     } catch (std::out_of_range& e) {
80699       {
80700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80701       };
80702     } catch (std::exception& e) {
80703       {
80704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80705       };
80706     } catch (Dali::DaliException e) {
80707       {
80708         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80709       };
80710     } catch (...) {
80711       {
80712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80713       };
80714     }
80715   }
80716
80717 }
80718
80719
80720 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootDuration(void * jarg1, float jarg2) {
80721   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80722   float arg2 ;
80723
80724   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80725   arg2 = (float)jarg2;
80726   {
80727     try {
80728       (arg1)->SetSnapOvershootDuration(arg2);
80729     } catch (std::out_of_range& e) {
80730       {
80731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80732       };
80733     } catch (std::exception& e) {
80734       {
80735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80736       };
80737     } catch (Dali::DaliException e) {
80738       {
80739         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80740       };
80741     } catch (...) {
80742       {
80743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80744       };
80745     }
80746   }
80747
80748 }
80749
80750
80751 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetActorAutoSnap(void * jarg1, unsigned int jarg2) {
80752   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80753   bool arg2 ;
80754
80755   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80756   arg2 = jarg2 ? true : false;
80757   {
80758     try {
80759       (arg1)->SetActorAutoSnap(arg2);
80760     } catch (std::out_of_range& e) {
80761       {
80762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80763       };
80764     } catch (std::exception& e) {
80765       {
80766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80767       };
80768     } catch (Dali::DaliException e) {
80769       {
80770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80771       };
80772     } catch (...) {
80773       {
80774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80775       };
80776     }
80777   }
80778
80779 }
80780
80781
80782 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWrapMode(void * jarg1, unsigned int jarg2) {
80783   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80784   bool arg2 ;
80785
80786   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80787   arg2 = jarg2 ? true : false;
80788   {
80789     try {
80790       (arg1)->SetWrapMode(arg2);
80791     } catch (std::out_of_range& e) {
80792       {
80793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80794       };
80795     } catch (std::exception& e) {
80796       {
80797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80798       };
80799     } catch (Dali::DaliException e) {
80800       {
80801         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80802       };
80803     } catch (...) {
80804       {
80805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80806       };
80807     }
80808   }
80809
80810 }
80811
80812
80813 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollUpdateDistance(void * jarg1) {
80814   int jresult ;
80815   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80816   int result;
80817
80818   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80819   {
80820     try {
80821       result = (int)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollUpdateDistance();
80822     } catch (std::out_of_range& e) {
80823       {
80824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80825       };
80826     } catch (std::exception& e) {
80827       {
80828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80829       };
80830     } catch (Dali::DaliException e) {
80831       {
80832         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80833       };
80834     } catch (...) {
80835       {
80836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80837       };
80838     }
80839   }
80840
80841   jresult = result;
80842   return jresult;
80843 }
80844
80845
80846 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollUpdateDistance(void * jarg1, int jarg2) {
80847   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80848   int arg2 ;
80849
80850   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80851   arg2 = (int)jarg2;
80852   {
80853     try {
80854       (arg1)->SetScrollUpdateDistance(arg2);
80855     } catch (std::out_of_range& e) {
80856       {
80857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80858       };
80859     } catch (std::exception& e) {
80860       {
80861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80862       };
80863     } catch (Dali::DaliException e) {
80864       {
80865         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80866       };
80867     } catch (...) {
80868       {
80869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80870       };
80871     }
80872   }
80873
80874 }
80875
80876
80877 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLock(void * jarg1) {
80878   unsigned int jresult ;
80879   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80880   bool result;
80881
80882   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80883   {
80884     try {
80885       result = (bool)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLock();
80886     } catch (std::out_of_range& e) {
80887       {
80888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80889       };
80890     } catch (std::exception& e) {
80891       {
80892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80893       };
80894     } catch (Dali::DaliException e) {
80895       {
80896         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80897       };
80898     } catch (...) {
80899       {
80900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80901       };
80902     }
80903   }
80904
80905   jresult = result;
80906   return jresult;
80907 }
80908
80909
80910 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLock(void * jarg1, unsigned int jarg2) {
80911   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80912   bool arg2 ;
80913
80914   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80915   arg2 = jarg2 ? true : false;
80916   {
80917     try {
80918       (arg1)->SetAxisAutoLock(arg2);
80919     } catch (std::out_of_range& e) {
80920       {
80921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80922       };
80923     } catch (std::exception& e) {
80924       {
80925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80926       };
80927     } catch (Dali::DaliException e) {
80928       {
80929         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80930       };
80931     } catch (...) {
80932       {
80933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80934       };
80935     }
80936   }
80937
80938 }
80939
80940
80941 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLockGradient(void * jarg1) {
80942   float jresult ;
80943   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80944   float result;
80945
80946   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80947   {
80948     try {
80949       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLockGradient();
80950     } catch (std::out_of_range& e) {
80951       {
80952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80953       };
80954     } catch (std::exception& e) {
80955       {
80956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80957       };
80958     } catch (Dali::DaliException e) {
80959       {
80960         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80961       };
80962     } catch (...) {
80963       {
80964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80965       };
80966     }
80967   }
80968
80969   jresult = result;
80970   return jresult;
80971 }
80972
80973
80974 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLockGradient(void * jarg1, float jarg2) {
80975   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80976   float arg2 ;
80977
80978   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80979   arg2 = (float)jarg2;
80980   {
80981     try {
80982       (arg1)->SetAxisAutoLockGradient(arg2);
80983     } catch (std::out_of_range& e) {
80984       {
80985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80986       };
80987     } catch (std::exception& e) {
80988       {
80989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80990       };
80991     } catch (Dali::DaliException e) {
80992       {
80993         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80994       };
80995     } catch (...) {
80996       {
80997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80998       };
80999     }
81000   }
81001
81002 }
81003
81004
81005 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFrictionCoefficient(void * jarg1) {
81006   float jresult ;
81007   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81008   float result;
81009
81010   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81011   {
81012     try {
81013       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFrictionCoefficient();
81014     } catch (std::out_of_range& e) {
81015       {
81016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81017       };
81018     } catch (std::exception& e) {
81019       {
81020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81021       };
81022     } catch (Dali::DaliException e) {
81023       {
81024         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81025       };
81026     } catch (...) {
81027       {
81028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81029       };
81030     }
81031   }
81032
81033   jresult = result;
81034   return jresult;
81035 }
81036
81037
81038 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFrictionCoefficient(void * jarg1, float jarg2) {
81039   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81040   float arg2 ;
81041
81042   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81043   arg2 = (float)jarg2;
81044   {
81045     try {
81046       (arg1)->SetFrictionCoefficient(arg2);
81047     } catch (std::out_of_range& e) {
81048       {
81049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81050       };
81051     } catch (std::exception& e) {
81052       {
81053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81054       };
81055     } catch (Dali::DaliException e) {
81056       {
81057         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81058       };
81059     } catch (...) {
81060       {
81061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81062       };
81063     }
81064   }
81065
81066 }
81067
81068
81069 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFlickSpeedCoefficient(void * jarg1) {
81070   float jresult ;
81071   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81072   float result;
81073
81074   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81075   {
81076     try {
81077       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFlickSpeedCoefficient();
81078     } catch (std::out_of_range& e) {
81079       {
81080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81081       };
81082     } catch (std::exception& e) {
81083       {
81084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81085       };
81086     } catch (Dali::DaliException e) {
81087       {
81088         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81089       };
81090     } catch (...) {
81091       {
81092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81093       };
81094     }
81095   }
81096
81097   jresult = result;
81098   return jresult;
81099 }
81100
81101
81102 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFlickSpeedCoefficient(void * jarg1, float jarg2) {
81103   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81104   float arg2 ;
81105
81106   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81107   arg2 = (float)jarg2;
81108   {
81109     try {
81110       (arg1)->SetFlickSpeedCoefficient(arg2);
81111     } catch (std::out_of_range& e) {
81112       {
81113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81114       };
81115     } catch (std::exception& e) {
81116       {
81117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81118       };
81119     } catch (Dali::DaliException e) {
81120       {
81121         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81122       };
81123     } catch (...) {
81124       {
81125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81126       };
81127     }
81128   }
81129
81130 }
81131
81132
81133 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumDistanceForFlick(void * jarg1) {
81134   void * jresult ;
81135   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81136   Dali::Vector2 result;
81137
81138   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81139   {
81140     try {
81141       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumDistanceForFlick();
81142     } catch (std::out_of_range& e) {
81143       {
81144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81145       };
81146     } catch (std::exception& e) {
81147       {
81148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81149       };
81150     } catch (Dali::DaliException e) {
81151       {
81152         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81153       };
81154     } catch (...) {
81155       {
81156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81157       };
81158     }
81159   }
81160
81161   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
81162   return jresult;
81163 }
81164
81165
81166 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumDistanceForFlick(void * jarg1, void * jarg2) {
81167   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81168   Dali::Vector2 *arg2 = 0 ;
81169
81170   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81171   arg2 = (Dali::Vector2 *)jarg2;
81172   if (!arg2) {
81173     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81174     return ;
81175   }
81176   {
81177     try {
81178       (arg1)->SetMinimumDistanceForFlick((Dali::Vector2 const &)*arg2);
81179     } catch (std::out_of_range& e) {
81180       {
81181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81182       };
81183     } catch (std::exception& e) {
81184       {
81185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81186       };
81187     } catch (Dali::DaliException e) {
81188       {
81189         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81190       };
81191     } catch (...) {
81192       {
81193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81194       };
81195     }
81196   }
81197
81198 }
81199
81200
81201 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumSpeedForFlick(void * jarg1) {
81202   float jresult ;
81203   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81204   float result;
81205
81206   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81207   {
81208     try {
81209       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumSpeedForFlick();
81210     } catch (std::out_of_range& e) {
81211       {
81212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81213       };
81214     } catch (std::exception& e) {
81215       {
81216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81217       };
81218     } catch (Dali::DaliException e) {
81219       {
81220         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81221       };
81222     } catch (...) {
81223       {
81224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81225       };
81226     }
81227   }
81228
81229   jresult = result;
81230   return jresult;
81231 }
81232
81233
81234 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumSpeedForFlick(void * jarg1, float jarg2) {
81235   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81236   float arg2 ;
81237
81238   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81239   arg2 = (float)jarg2;
81240   {
81241     try {
81242       (arg1)->SetMinimumSpeedForFlick(arg2);
81243     } catch (std::out_of_range& e) {
81244       {
81245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81246       };
81247     } catch (std::exception& e) {
81248       {
81249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81250       };
81251     } catch (Dali::DaliException e) {
81252       {
81253         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81254       };
81255     } catch (...) {
81256       {
81257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81258       };
81259     }
81260   }
81261
81262 }
81263
81264
81265 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMaxFlickSpeed(void * jarg1) {
81266   float jresult ;
81267   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81268   float result;
81269
81270   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81271   {
81272     try {
81273       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMaxFlickSpeed();
81274     } catch (std::out_of_range& e) {
81275       {
81276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81277       };
81278     } catch (std::exception& e) {
81279       {
81280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81281       };
81282     } catch (Dali::DaliException e) {
81283       {
81284         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81285       };
81286     } catch (...) {
81287       {
81288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81289       };
81290     }
81291   }
81292
81293   jresult = result;
81294   return jresult;
81295 }
81296
81297
81298 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxFlickSpeed(void * jarg1, float jarg2) {
81299   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81300   float arg2 ;
81301
81302   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81303   arg2 = (float)jarg2;
81304   {
81305     try {
81306       (arg1)->SetMaxFlickSpeed(arg2);
81307     } catch (std::out_of_range& e) {
81308       {
81309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81310       };
81311     } catch (std::exception& e) {
81312       {
81313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81314       };
81315     } catch (Dali::DaliException e) {
81316       {
81317         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81318       };
81319     } catch (...) {
81320       {
81321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81322       };
81323     }
81324   }
81325
81326 }
81327
81328
81329 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetWheelScrollDistanceStep(void * jarg1) {
81330   void * jresult ;
81331   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81332   Dali::Vector2 result;
81333
81334   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81335   {
81336     try {
81337       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetWheelScrollDistanceStep();
81338     } catch (std::out_of_range& e) {
81339       {
81340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81341       };
81342     } catch (std::exception& e) {
81343       {
81344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81345       };
81346     } catch (Dali::DaliException e) {
81347       {
81348         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81349       };
81350     } catch (...) {
81351       {
81352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81353       };
81354     }
81355   }
81356
81357   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
81358   return jresult;
81359 }
81360
81361
81362 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWheelScrollDistanceStep(void * jarg1, void * jarg2) {
81363   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81364   Dali::Vector2 arg2 ;
81365   Dali::Vector2 *argp2 ;
81366
81367   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81368   argp2 = (Dali::Vector2 *)jarg2;
81369   if (!argp2) {
81370     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
81371     return ;
81372   }
81373   arg2 = *argp2;
81374   {
81375     try {
81376       (arg1)->SetWheelScrollDistanceStep(arg2);
81377     } catch (std::out_of_range& e) {
81378       {
81379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81380       };
81381     } catch (std::exception& e) {
81382       {
81383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81384       };
81385     } catch (Dali::DaliException e) {
81386       {
81387         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81388       };
81389     } catch (...) {
81390       {
81391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81392       };
81393     }
81394   }
81395
81396 }
81397
81398
81399 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentScrollPosition(void * jarg1) {
81400   void * jresult ;
81401   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81402   Dali::Vector2 result;
81403
81404   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81405   {
81406     try {
81407       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentScrollPosition();
81408     } catch (std::out_of_range& e) {
81409       {
81410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81411       };
81412     } catch (std::exception& e) {
81413       {
81414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81415       };
81416     } catch (Dali::DaliException e) {
81417       {
81418         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81419       };
81420     } catch (...) {
81421       {
81422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81423       };
81424     }
81425   }
81426
81427   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
81428   return jresult;
81429 }
81430
81431
81432 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentPage(void * jarg1) {
81433   unsigned int jresult ;
81434   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81435   unsigned int result;
81436
81437   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81438   {
81439     try {
81440       result = (unsigned int)((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentPage();
81441     } catch (std::out_of_range& e) {
81442       {
81443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81444       };
81445     } catch (std::exception& e) {
81446       {
81447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81448       };
81449     } catch (Dali::DaliException e) {
81450       {
81451         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81452       };
81453     } catch (...) {
81454       {
81455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81456       };
81457     }
81458   }
81459
81460   jresult = result;
81461   return jresult;
81462 }
81463
81464
81465 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_0(void * jarg1, void * jarg2) {
81466   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81467   Dali::Vector2 *arg2 = 0 ;
81468
81469   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81470   arg2 = (Dali::Vector2 *)jarg2;
81471   if (!arg2) {
81472     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81473     return ;
81474   }
81475   {
81476     try {
81477       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2);
81478     } catch (std::out_of_range& e) {
81479       {
81480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81481       };
81482     } catch (std::exception& e) {
81483       {
81484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81485       };
81486     } catch (Dali::DaliException e) {
81487       {
81488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81489       };
81490     } catch (...) {
81491       {
81492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81493       };
81494     }
81495   }
81496
81497 }
81498
81499
81500 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
81501   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81502   Dali::Vector2 *arg2 = 0 ;
81503   float arg3 ;
81504
81505   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81506   arg2 = (Dali::Vector2 *)jarg2;
81507   if (!arg2) {
81508     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81509     return ;
81510   }
81511   arg3 = (float)jarg3;
81512   {
81513     try {
81514       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3);
81515     } catch (std::out_of_range& e) {
81516       {
81517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81518       };
81519     } catch (std::exception& e) {
81520       {
81521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81522       };
81523     } catch (Dali::DaliException e) {
81524       {
81525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81526       };
81527     } catch (...) {
81528       {
81529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81530       };
81531     }
81532   }
81533
81534 }
81535
81536
81537 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_2(void * jarg1, void * jarg2, float jarg3, void * jarg4) {
81538   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81539   Dali::Vector2 *arg2 = 0 ;
81540   float arg3 ;
81541   Dali::AlphaFunction arg4 ;
81542   Dali::AlphaFunction *argp4 ;
81543
81544   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81545   arg2 = (Dali::Vector2 *)jarg2;
81546   if (!arg2) {
81547     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81548     return ;
81549   }
81550   arg3 = (float)jarg3;
81551   argp4 = (Dali::AlphaFunction *)jarg4;
81552   if (!argp4) {
81553     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
81554     return ;
81555   }
81556   arg4 = *argp4;
81557   {
81558     try {
81559       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4);
81560     } catch (std::out_of_range& e) {
81561       {
81562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81563       };
81564     } catch (std::exception& e) {
81565       {
81566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81567       };
81568     } catch (Dali::DaliException e) {
81569       {
81570         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81571       };
81572     } catch (...) {
81573       {
81574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81575       };
81576     }
81577   }
81578
81579 }
81580
81581
81582 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_3(void * jarg1, void * jarg2, float jarg3, int jarg4, int jarg5) {
81583   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81584   Dali::Vector2 *arg2 = 0 ;
81585   float arg3 ;
81586   Dali::Toolkit::DirectionBias arg4 ;
81587   Dali::Toolkit::DirectionBias arg5 ;
81588
81589   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81590   arg2 = (Dali::Vector2 *)jarg2;
81591   if (!arg2) {
81592     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81593     return ;
81594   }
81595   arg3 = (float)jarg3;
81596   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
81597   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
81598   {
81599     try {
81600       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5);
81601     } catch (std::out_of_range& e) {
81602       {
81603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81604       };
81605     } catch (std::exception& e) {
81606       {
81607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81608       };
81609     } catch (Dali::DaliException e) {
81610       {
81611         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81612       };
81613     } catch (...) {
81614       {
81615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81616       };
81617     }
81618   }
81619
81620 }
81621
81622
81623 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_4(void * jarg1, void * jarg2, float jarg3, void * jarg4, int jarg5, int jarg6) {
81624   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81625   Dali::Vector2 *arg2 = 0 ;
81626   float arg3 ;
81627   Dali::AlphaFunction arg4 ;
81628   Dali::Toolkit::DirectionBias arg5 ;
81629   Dali::Toolkit::DirectionBias arg6 ;
81630   Dali::AlphaFunction *argp4 ;
81631
81632   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81633   arg2 = (Dali::Vector2 *)jarg2;
81634   if (!arg2) {
81635     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81636     return ;
81637   }
81638   arg3 = (float)jarg3;
81639   argp4 = (Dali::AlphaFunction *)jarg4;
81640   if (!argp4) {
81641     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
81642     return ;
81643   }
81644   arg4 = *argp4;
81645   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
81646   arg6 = (Dali::Toolkit::DirectionBias)jarg6;
81647   {
81648     try {
81649       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5,arg6);
81650     } catch (std::out_of_range& e) {
81651       {
81652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81653       };
81654     } catch (std::exception& e) {
81655       {
81656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81657       };
81658     } catch (Dali::DaliException e) {
81659       {
81660         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81661       };
81662     } catch (...) {
81663       {
81664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81665       };
81666     }
81667   }
81668
81669 }
81670
81671
81672 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_5(void * jarg1, unsigned int jarg2) {
81673   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81674   unsigned int arg2 ;
81675
81676   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81677   arg2 = (unsigned int)jarg2;
81678   {
81679     try {
81680       (arg1)->ScrollTo(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_ScrollTo__SWIG_6(void * jarg1, unsigned int jarg2, float jarg3) {
81704   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81705   unsigned int arg2 ;
81706   float arg3 ;
81707
81708   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81709   arg2 = (unsigned int)jarg2;
81710   arg3 = (float)jarg3;
81711   {
81712     try {
81713       (arg1)->ScrollTo(arg2,arg3);
81714     } catch (std::out_of_range& e) {
81715       {
81716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81717       };
81718     } catch (std::exception& e) {
81719       {
81720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81721       };
81722     } catch (Dali::DaliException e) {
81723       {
81724         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81725       };
81726     } catch (...) {
81727       {
81728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81729       };
81730     }
81731   }
81732
81733 }
81734
81735
81736 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_7(void * jarg1, unsigned int jarg2, float jarg3, int jarg4) {
81737   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81738   unsigned int arg2 ;
81739   float arg3 ;
81740   Dali::Toolkit::DirectionBias arg4 ;
81741
81742   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81743   arg2 = (unsigned int)jarg2;
81744   arg3 = (float)jarg3;
81745   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
81746   {
81747     try {
81748       (arg1)->ScrollTo(arg2,arg3,arg4);
81749     } catch (std::out_of_range& e) {
81750       {
81751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81752       };
81753     } catch (std::exception& e) {
81754       {
81755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81756       };
81757     } catch (Dali::DaliException e) {
81758       {
81759         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81760       };
81761     } catch (...) {
81762       {
81763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81764       };
81765     }
81766   }
81767
81768 }
81769
81770
81771 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_8(void * jarg1, void * jarg2) {
81772   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81773   Dali::Actor *arg2 = 0 ;
81774
81775   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81776   arg2 = (Dali::Actor *)jarg2;
81777   if (!arg2) {
81778     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
81779     return ;
81780   }
81781   {
81782     try {
81783       (arg1)->ScrollTo(*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_ScrollTo__SWIG_9(void * jarg1, void * jarg2, float jarg3) {
81807   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81808   Dali::Actor *arg2 = 0 ;
81809   float arg3 ;
81810
81811   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81812   arg2 = (Dali::Actor *)jarg2;
81813   if (!arg2) {
81814     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
81815     return ;
81816   }
81817   arg3 = (float)jarg3;
81818   {
81819     try {
81820       (arg1)->ScrollTo(*arg2,arg3);
81821     } catch (std::out_of_range& e) {
81822       {
81823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81824       };
81825     } catch (std::exception& e) {
81826       {
81827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81828       };
81829     } catch (Dali::DaliException e) {
81830       {
81831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81832       };
81833     } catch (...) {
81834       {
81835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81836       };
81837     }
81838   }
81839
81840 }
81841
81842
81843 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_ScrollToSnapPoint(void * jarg1) {
81844   unsigned int jresult ;
81845   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81846   bool result;
81847
81848   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81849   {
81850     try {
81851       result = (bool)(arg1)->ScrollToSnapPoint();
81852     } catch (std::out_of_range& e) {
81853       {
81854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81855       };
81856     } catch (std::exception& e) {
81857       {
81858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81859       };
81860     } catch (Dali::DaliException e) {
81861       {
81862         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81863       };
81864     } catch (...) {
81865       {
81866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81867       };
81868     }
81869   }
81870
81871   jresult = result;
81872   return jresult;
81873 }
81874
81875
81876 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyConstraintToChildren(void * jarg1, void * jarg2) {
81877   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81878   Dali::Constraint arg2 ;
81879   Dali::Constraint *argp2 ;
81880
81881   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81882   argp2 = (Dali::Constraint *)jarg2;
81883   if (!argp2) {
81884     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Constraint", 0);
81885     return ;
81886   }
81887   arg2 = *argp2;
81888   {
81889     try {
81890       (arg1)->ApplyConstraintToChildren(arg2);
81891     } catch (std::out_of_range& e) {
81892       {
81893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81894       };
81895     } catch (std::exception& e) {
81896       {
81897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81898       };
81899     } catch (Dali::DaliException e) {
81900       {
81901         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81902       };
81903     } catch (...) {
81904       {
81905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81906       };
81907     }
81908   }
81909
81910 }
81911
81912
81913 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveConstraintsFromChildren(void * jarg1) {
81914   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81915
81916   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81917   {
81918     try {
81919       (arg1)->RemoveConstraintsFromChildren();
81920     } catch (std::out_of_range& e) {
81921       {
81922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81923       };
81924     } catch (std::exception& e) {
81925       {
81926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81927       };
81928     } catch (Dali::DaliException e) {
81929       {
81930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81931       };
81932     } catch (...) {
81933       {
81934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81935       };
81936     }
81937   }
81938
81939 }
81940
81941
81942 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyEffect(void * jarg1, void * jarg2) {
81943   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81944   Dali::Toolkit::ScrollViewEffect arg2 ;
81945   Dali::Toolkit::ScrollViewEffect *argp2 ;
81946
81947   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81948   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
81949   if (!argp2) {
81950     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
81951     return ;
81952   }
81953   arg2 = *argp2;
81954   {
81955     try {
81956       (arg1)->ApplyEffect(arg2);
81957     } catch (std::out_of_range& e) {
81958       {
81959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81960       };
81961     } catch (std::exception& e) {
81962       {
81963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81964       };
81965     } catch (Dali::DaliException e) {
81966       {
81967         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81968       };
81969     } catch (...) {
81970       {
81971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81972       };
81973     }
81974   }
81975
81976 }
81977
81978
81979 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveEffect(void * jarg1, void * jarg2) {
81980   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81981   Dali::Toolkit::ScrollViewEffect arg2 ;
81982   Dali::Toolkit::ScrollViewEffect *argp2 ;
81983
81984   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81985   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
81986   if (!argp2) {
81987     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
81988     return ;
81989   }
81990   arg2 = *argp2;
81991   {
81992     try {
81993       (arg1)->RemoveEffect(arg2);
81994     } catch (std::out_of_range& e) {
81995       {
81996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81997       };
81998     } catch (std::exception& e) {
81999       {
82000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82001       };
82002     } catch (Dali::DaliException e) {
82003       {
82004         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82005       };
82006     } catch (...) {
82007       {
82008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82009       };
82010     }
82011   }
82012
82013 }
82014
82015
82016 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveAllEffects(void * jarg1) {
82017   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82018
82019   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82020   {
82021     try {
82022       (arg1)->RemoveAllEffects();
82023     } catch (std::out_of_range& e) {
82024       {
82025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82026       };
82027     } catch (std::exception& e) {
82028       {
82029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82030       };
82031     } catch (Dali::DaliException e) {
82032       {
82033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82034       };
82035     } catch (...) {
82036       {
82037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82038       };
82039     }
82040   }
82041
82042 }
82043
82044
82045 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_BindActor(void * jarg1, void * jarg2) {
82046   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82047   Dali::Actor arg2 ;
82048   Dali::Actor *argp2 ;
82049
82050   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82051   argp2 = (Dali::Actor *)jarg2;
82052   if (!argp2) {
82053     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82054     return ;
82055   }
82056   arg2 = *argp2;
82057   {
82058     try {
82059       (arg1)->BindActor(arg2);
82060     } catch (std::out_of_range& e) {
82061       {
82062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82063       };
82064     } catch (std::exception& e) {
82065       {
82066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82067       };
82068     } catch (Dali::DaliException e) {
82069       {
82070         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82071       };
82072     } catch (...) {
82073       {
82074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82075       };
82076     }
82077   }
82078
82079 }
82080
82081
82082 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_UnbindActor(void * jarg1, void * jarg2) {
82083   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82084   Dali::Actor arg2 ;
82085   Dali::Actor *argp2 ;
82086
82087   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82088   argp2 = (Dali::Actor *)jarg2;
82089   if (!argp2) {
82090     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82091     return ;
82092   }
82093   arg2 = *argp2;
82094   {
82095     try {
82096       (arg1)->UnbindActor(arg2);
82097     } catch (std::out_of_range& e) {
82098       {
82099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82100       };
82101     } catch (std::exception& e) {
82102       {
82103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82104       };
82105     } catch (Dali::DaliException e) {
82106       {
82107         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82108       };
82109     } catch (...) {
82110       {
82111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82112       };
82113     }
82114   }
82115
82116 }
82117
82118
82119 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
82120   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82121   Dali::Radian arg2 ;
82122   Dali::Radian arg3 ;
82123   Dali::Radian *argp2 ;
82124   Dali::Radian *argp3 ;
82125
82126   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82127   argp2 = (Dali::Radian *)jarg2;
82128   if (!argp2) {
82129     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
82130     return ;
82131   }
82132   arg2 = *argp2;
82133   argp3 = (Dali::Radian *)jarg3;
82134   if (!argp3) {
82135     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
82136     return ;
82137   }
82138   arg3 = *argp3;
82139   {
82140     try {
82141       (arg1)->SetScrollingDirection(arg2,arg3);
82142     } catch (std::out_of_range& e) {
82143       {
82144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82145       };
82146     } catch (std::exception& e) {
82147       {
82148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82149       };
82150     } catch (Dali::DaliException e) {
82151       {
82152         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82153       };
82154     } catch (...) {
82155       {
82156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82157       };
82158     }
82159   }
82160
82161 }
82162
82163
82164 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_1(void * jarg1, void * jarg2) {
82165   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82166   Dali::Radian arg2 ;
82167   Dali::Radian *argp2 ;
82168
82169   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82170   argp2 = (Dali::Radian *)jarg2;
82171   if (!argp2) {
82172     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
82173     return ;
82174   }
82175   arg2 = *argp2;
82176   {
82177     try {
82178       (arg1)->SetScrollingDirection(arg2);
82179     } catch (std::out_of_range& e) {
82180       {
82181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82182       };
82183     } catch (std::exception& e) {
82184       {
82185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82186       };
82187     } catch (Dali::DaliException e) {
82188       {
82189         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82190       };
82191     } catch (...) {
82192       {
82193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82194       };
82195     }
82196   }
82197
82198 }
82199
82200
82201 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveScrollingDirection(void * jarg1, void * jarg2) {
82202   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82203   Dali::Radian arg2 ;
82204   Dali::Radian *argp2 ;
82205
82206   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82207   argp2 = (Dali::Radian *)jarg2;
82208   if (!argp2) {
82209     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
82210     return ;
82211   }
82212   arg2 = *argp2;
82213   {
82214     try {
82215       (arg1)->RemoveScrollingDirection(arg2);
82216     } catch (std::out_of_range& e) {
82217       {
82218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82219       };
82220     } catch (std::exception& e) {
82221       {
82222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82223       };
82224     } catch (Dali::DaliException e) {
82225       {
82226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82227       };
82228     } catch (...) {
82229       {
82230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82231       };
82232     }
82233   }
82234
82235 }
82236
82237
82238 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapStartedSignal(void * jarg1) {
82239   void * jresult ;
82240   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82241   Dali::Toolkit::ScrollView::SnapStartedSignalType *result = 0 ;
82242
82243   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82244   {
82245     try {
82246       result = (Dali::Toolkit::ScrollView::SnapStartedSignalType *) &(arg1)->SnapStartedSignal();
82247     } catch (std::out_of_range& e) {
82248       {
82249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82250       };
82251     } catch (std::exception& e) {
82252       {
82253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82254       };
82255     } catch (Dali::DaliException e) {
82256       {
82257         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82258       };
82259     } catch (...) {
82260       {
82261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82262       };
82263     }
82264   }
82265
82266   jresult = (void *)result;
82267   return jresult;
82268 }
82269
82270
82271 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_ROWS_get() {
82272   int jresult ;
82273   int result;
82274
82275   result = (int)Dali::Toolkit::TableView::Property::ROWS;
82276   jresult = (int)result;
82277   return jresult;
82278 }
82279
82280
82281 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_COLUMNS_get() {
82282   int jresult ;
82283   int result;
82284
82285   result = (int)Dali::Toolkit::TableView::Property::COLUMNS;
82286   jresult = (int)result;
82287   return jresult;
82288 }
82289
82290
82291 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_CELL_PADDING_get() {
82292   int jresult ;
82293   int result;
82294
82295   result = (int)Dali::Toolkit::TableView::Property::CELL_PADDING;
82296   jresult = (int)result;
82297   return jresult;
82298 }
82299
82300
82301 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_ROWS_get() {
82302   int jresult ;
82303   int result;
82304
82305   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_ROWS;
82306   jresult = (int)result;
82307   return jresult;
82308 }
82309
82310
82311 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_COLUMNS_get() {
82312   int jresult ;
82313   int result;
82314
82315   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_COLUMNS;
82316   jresult = (int)result;
82317   return jresult;
82318 }
82319
82320
82321 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_Property() {
82322   void * jresult ;
82323   Dali::Toolkit::TableView::Property *result = 0 ;
82324
82325   {
82326     try {
82327       result = (Dali::Toolkit::TableView::Property *)new Dali::Toolkit::TableView::Property();
82328     } catch (std::out_of_range& e) {
82329       {
82330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82331       };
82332     } catch (std::exception& e) {
82333       {
82334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82335       };
82336     } catch (Dali::DaliException e) {
82337       {
82338         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82339       };
82340     } catch (...) {
82341       {
82342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82343       };
82344     }
82345   }
82346
82347   jresult = (void *)result;
82348   return jresult;
82349 }
82350
82351
82352 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_Property(void * jarg1) {
82353   Dali::Toolkit::TableView::Property *arg1 = (Dali::Toolkit::TableView::Property *) 0 ;
82354
82355   arg1 = (Dali::Toolkit::TableView::Property *)jarg1;
82356   {
82357     try {
82358       delete arg1;
82359     } catch (std::out_of_range& e) {
82360       {
82361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82362       };
82363     } catch (std::exception& e) {
82364       {
82365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82366       };
82367     } catch (Dali::DaliException e) {
82368       {
82369         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82370       };
82371     } catch (...) {
82372       {
82373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82374       };
82375     }
82376   }
82377
82378 }
82379
82380
82381 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_INDEX_get() {
82382   int jresult ;
82383   int result;
82384
82385   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_INDEX;
82386   jresult = (int)result;
82387   return jresult;
82388 }
82389
82390
82391 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_ROW_SPAN_get() {
82392   int jresult ;
82393   int result;
82394
82395   result = (int)Dali::Toolkit::TableView::ChildProperty::ROW_SPAN;
82396   jresult = (int)result;
82397   return jresult;
82398 }
82399
82400
82401 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_COLUMN_SPAN_get() {
82402   int jresult ;
82403   int result;
82404
82405   result = (int)Dali::Toolkit::TableView::ChildProperty::COLUMN_SPAN;
82406   jresult = (int)result;
82407   return jresult;
82408 }
82409
82410
82411 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_HORIZONTAL_ALIGNMENT_get() {
82412   int jresult ;
82413   int result;
82414
82415   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_HORIZONTAL_ALIGNMENT;
82416   jresult = (int)result;
82417   return jresult;
82418 }
82419
82420
82421 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_VERTICAL_ALIGNMENT_get() {
82422   int jresult ;
82423   int result;
82424
82425   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_VERTICAL_ALIGNMENT;
82426   jresult = (int)result;
82427   return jresult;
82428 }
82429
82430
82431 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_ChildProperty() {
82432   void * jresult ;
82433   Dali::Toolkit::TableView::ChildProperty *result = 0 ;
82434
82435   {
82436     try {
82437       result = (Dali::Toolkit::TableView::ChildProperty *)new Dali::Toolkit::TableView::ChildProperty();
82438     } catch (std::out_of_range& e) {
82439       {
82440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82441       };
82442     } catch (std::exception& e) {
82443       {
82444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82445       };
82446     } catch (Dali::DaliException e) {
82447       {
82448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82449       };
82450     } catch (...) {
82451       {
82452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82453       };
82454     }
82455   }
82456
82457   jresult = (void *)result;
82458   return jresult;
82459 }
82460
82461
82462 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_ChildProperty(void * jarg1) {
82463   Dali::Toolkit::TableView::ChildProperty *arg1 = (Dali::Toolkit::TableView::ChildProperty *) 0 ;
82464
82465   arg1 = (Dali::Toolkit::TableView::ChildProperty *)jarg1;
82466   {
82467     try {
82468       delete arg1;
82469     } catch (std::out_of_range& e) {
82470       {
82471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82472       };
82473     } catch (std::exception& e) {
82474       {
82475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82476       };
82477     } catch (Dali::DaliException e) {
82478       {
82479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82480       };
82481     } catch (...) {
82482       {
82483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82484       };
82485     }
82486   }
82487
82488 }
82489
82490
82491 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_0(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4) {
82492   void * jresult ;
82493   unsigned int arg1 ;
82494   unsigned int arg2 ;
82495   unsigned int arg3 ;
82496   unsigned int arg4 ;
82497   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82498
82499   arg1 = (unsigned int)jarg1;
82500   arg2 = (unsigned int)jarg2;
82501   arg3 = (unsigned int)jarg3;
82502   arg4 = (unsigned int)jarg4;
82503   {
82504     try {
82505       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3,arg4);
82506     } catch (std::out_of_range& e) {
82507       {
82508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82509       };
82510     } catch (std::exception& e) {
82511       {
82512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82513       };
82514     } catch (Dali::DaliException e) {
82515       {
82516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82517       };
82518     } catch (...) {
82519       {
82520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82521       };
82522     }
82523   }
82524
82525   jresult = (void *)result;
82526   return jresult;
82527 }
82528
82529
82530 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_1(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
82531   void * jresult ;
82532   unsigned int arg1 ;
82533   unsigned int arg2 ;
82534   unsigned int arg3 ;
82535   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82536
82537   arg1 = (unsigned int)jarg1;
82538   arg2 = (unsigned int)jarg2;
82539   arg3 = (unsigned int)jarg3;
82540   {
82541     try {
82542       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3);
82543     } catch (std::out_of_range& e) {
82544       {
82545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82546       };
82547     } catch (std::exception& e) {
82548       {
82549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82550       };
82551     } catch (Dali::DaliException e) {
82552       {
82553         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82554       };
82555     } catch (...) {
82556       {
82557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82558       };
82559     }
82560   }
82561
82562   jresult = (void *)result;
82563   return jresult;
82564 }
82565
82566
82567 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
82568   void * jresult ;
82569   unsigned int arg1 ;
82570   unsigned int arg2 ;
82571   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82572
82573   arg1 = (unsigned int)jarg1;
82574   arg2 = (unsigned int)jarg2;
82575   {
82576     try {
82577       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2);
82578     } catch (std::out_of_range& e) {
82579       {
82580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82581       };
82582     } catch (std::exception& e) {
82583       {
82584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82585       };
82586     } catch (Dali::DaliException e) {
82587       {
82588         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82589       };
82590     } catch (...) {
82591       {
82592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82593       };
82594     }
82595   }
82596
82597   jresult = (void *)result;
82598   return jresult;
82599 }
82600
82601
82602 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_3(unsigned int jarg1) {
82603   void * jresult ;
82604   unsigned int arg1 ;
82605   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82606
82607   arg1 = (unsigned int)jarg1;
82608   {
82609     try {
82610       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1);
82611     } catch (std::out_of_range& e) {
82612       {
82613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82614       };
82615     } catch (std::exception& e) {
82616       {
82617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82618       };
82619     } catch (Dali::DaliException e) {
82620       {
82621         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82622       };
82623     } catch (...) {
82624       {
82625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82626       };
82627     }
82628   }
82629
82630   jresult = (void *)result;
82631   return jresult;
82632 }
82633
82634
82635 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_4() {
82636   void * jresult ;
82637   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82638
82639   {
82640     try {
82641       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition();
82642     } catch (std::out_of_range& e) {
82643       {
82644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82645       };
82646     } catch (std::exception& e) {
82647       {
82648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82649       };
82650     } catch (Dali::DaliException e) {
82651       {
82652         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82653       };
82654     } catch (...) {
82655       {
82656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82657       };
82658     }
82659   }
82660
82661   jresult = (void *)result;
82662   return jresult;
82663 }
82664
82665
82666 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_set(void * jarg1, unsigned int jarg2) {
82667   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82668   unsigned int arg2 ;
82669
82670   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82671   arg2 = (unsigned int)jarg2;
82672   if (arg1) (arg1)->rowIndex = arg2;
82673 }
82674
82675
82676 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_get(void * jarg1) {
82677   unsigned int jresult ;
82678   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82679   unsigned int result;
82680
82681   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82682   result = (unsigned int) ((arg1)->rowIndex);
82683   jresult = result;
82684   return jresult;
82685 }
82686
82687
82688 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_set(void * jarg1, unsigned int jarg2) {
82689   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82690   unsigned int arg2 ;
82691
82692   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82693   arg2 = (unsigned int)jarg2;
82694   if (arg1) (arg1)->columnIndex = arg2;
82695 }
82696
82697
82698 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_get(void * jarg1) {
82699   unsigned int jresult ;
82700   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82701   unsigned int result;
82702
82703   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82704   result = (unsigned int) ((arg1)->columnIndex);
82705   jresult = result;
82706   return jresult;
82707 }
82708
82709
82710 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_set(void * jarg1, unsigned int jarg2) {
82711   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82712   unsigned int arg2 ;
82713
82714   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82715   arg2 = (unsigned int)jarg2;
82716   if (arg1) (arg1)->rowSpan = arg2;
82717 }
82718
82719
82720 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_get(void * jarg1) {
82721   unsigned int jresult ;
82722   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82723   unsigned int result;
82724
82725   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82726   result = (unsigned int) ((arg1)->rowSpan);
82727   jresult = result;
82728   return jresult;
82729 }
82730
82731
82732 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_set(void * jarg1, unsigned int jarg2) {
82733   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82734   unsigned int arg2 ;
82735
82736   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82737   arg2 = (unsigned int)jarg2;
82738   if (arg1) (arg1)->columnSpan = arg2;
82739 }
82740
82741
82742 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_get(void * jarg1) {
82743   unsigned int jresult ;
82744   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82745   unsigned int result;
82746
82747   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82748   result = (unsigned int) ((arg1)->columnSpan);
82749   jresult = result;
82750   return jresult;
82751 }
82752
82753
82754 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_CellPosition(void * jarg1) {
82755   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82756
82757   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82758   {
82759     try {
82760       delete arg1;
82761     } catch (std::out_of_range& e) {
82762       {
82763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82764       };
82765     } catch (std::exception& e) {
82766       {
82767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82768       };
82769     } catch (Dali::DaliException e) {
82770       {
82771         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82772       };
82773     } catch (...) {
82774       {
82775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82776       };
82777     }
82778   }
82779
82780 }
82781
82782
82783 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_0() {
82784   void * jresult ;
82785   Dali::Toolkit::TableView *result = 0 ;
82786
82787   {
82788     try {
82789       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView();
82790     } catch (std::out_of_range& e) {
82791       {
82792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82793       };
82794     } catch (std::exception& e) {
82795       {
82796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82797       };
82798     } catch (Dali::DaliException e) {
82799       {
82800         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82801       };
82802     } catch (...) {
82803       {
82804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82805       };
82806     }
82807   }
82808
82809   jresult = (void *)result;
82810   return jresult;
82811 }
82812
82813
82814 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_1(void * jarg1) {
82815   void * jresult ;
82816   Dali::Toolkit::TableView *arg1 = 0 ;
82817   Dali::Toolkit::TableView *result = 0 ;
82818
82819   arg1 = (Dali::Toolkit::TableView *)jarg1;
82820   if (!arg1) {
82821     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
82822     return 0;
82823   }
82824   {
82825     try {
82826       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView((Dali::Toolkit::TableView const &)*arg1);
82827     } catch (std::out_of_range& e) {
82828       {
82829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82830       };
82831     } catch (std::exception& e) {
82832       {
82833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82834       };
82835     } catch (Dali::DaliException e) {
82836       {
82837         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82838       };
82839     } catch (...) {
82840       {
82841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82842       };
82843     }
82844   }
82845
82846   jresult = (void *)result;
82847   return jresult;
82848 }
82849
82850
82851 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_Assign(void * jarg1, void * jarg2) {
82852   void * jresult ;
82853   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82854   Dali::Toolkit::TableView *arg2 = 0 ;
82855   Dali::Toolkit::TableView *result = 0 ;
82856
82857   arg1 = (Dali::Toolkit::TableView *)jarg1;
82858   arg2 = (Dali::Toolkit::TableView *)jarg2;
82859   if (!arg2) {
82860     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
82861     return 0;
82862   }
82863   {
82864     try {
82865       result = (Dali::Toolkit::TableView *) &(arg1)->operator =((Dali::Toolkit::TableView const &)*arg2);
82866     } catch (std::out_of_range& e) {
82867       {
82868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82869       };
82870     } catch (std::exception& e) {
82871       {
82872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82873       };
82874     } catch (Dali::DaliException e) {
82875       {
82876         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82877       };
82878     } catch (...) {
82879       {
82880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82881       };
82882     }
82883   }
82884
82885   jresult = (void *)result;
82886   return jresult;
82887 }
82888
82889
82890 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView(void * jarg1) {
82891   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82892
82893   arg1 = (Dali::Toolkit::TableView *)jarg1;
82894   {
82895     try {
82896       delete arg1;
82897     } catch (std::out_of_range& e) {
82898       {
82899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82900       };
82901     } catch (std::exception& e) {
82902       {
82903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82904       };
82905     } catch (Dali::DaliException e) {
82906       {
82907         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82908       };
82909     } catch (...) {
82910       {
82911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82912       };
82913     }
82914   }
82915
82916 }
82917
82918
82919 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_New(unsigned int jarg1, unsigned int jarg2) {
82920   void * jresult ;
82921   unsigned int arg1 ;
82922   unsigned int arg2 ;
82923   Dali::Toolkit::TableView result;
82924
82925   arg1 = (unsigned int)jarg1;
82926   arg2 = (unsigned int)jarg2;
82927   {
82928     try {
82929       result = Dali::Toolkit::TableView::New(arg1,arg2);
82930     } catch (std::out_of_range& e) {
82931       {
82932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82933       };
82934     } catch (std::exception& e) {
82935       {
82936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82937       };
82938     } catch (Dali::DaliException e) {
82939       {
82940         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82941       };
82942     } catch (...) {
82943       {
82944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82945       };
82946     }
82947   }
82948
82949   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
82950   return jresult;
82951 }
82952
82953
82954 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_DownCast(void * jarg1) {
82955   void * jresult ;
82956   Dali::BaseHandle arg1 ;
82957   Dali::BaseHandle *argp1 ;
82958   Dali::Toolkit::TableView result;
82959
82960   argp1 = (Dali::BaseHandle *)jarg1;
82961   if (!argp1) {
82962     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
82963     return 0;
82964   }
82965   arg1 = *argp1;
82966   {
82967     try {
82968       result = Dali::Toolkit::TableView::DownCast(arg1);
82969     } catch (std::out_of_range& e) {
82970       {
82971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82972       };
82973     } catch (std::exception& e) {
82974       {
82975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82976       };
82977     } catch (Dali::DaliException e) {
82978       {
82979         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82980       };
82981     } catch (...) {
82982       {
82983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82984       };
82985     }
82986   }
82987
82988   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
82989   return jresult;
82990 }
82991
82992
82993 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_AddChild(void * jarg1, void * jarg2, void * jarg3) {
82994   unsigned int jresult ;
82995   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82996   Dali::Actor arg2 ;
82997   Dali::Toolkit::TableView::CellPosition arg3 ;
82998   Dali::Actor *argp2 ;
82999   Dali::Toolkit::TableView::CellPosition *argp3 ;
83000   bool result;
83001
83002   arg1 = (Dali::Toolkit::TableView *)jarg1;
83003   argp2 = (Dali::Actor *)jarg2;
83004   if (!argp2) {
83005     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83006     return 0;
83007   }
83008   arg2 = *argp2;
83009   argp3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
83010   if (!argp3) {
83011     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
83012     return 0;
83013   }
83014   arg3 = *argp3;
83015   {
83016     try {
83017       result = (bool)(arg1)->AddChild(arg2,arg3);
83018     } catch (std::out_of_range& e) {
83019       {
83020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83021       };
83022     } catch (std::exception& e) {
83023       {
83024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83025       };
83026     } catch (Dali::DaliException e) {
83027       {
83028         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83029       };
83030     } catch (...) {
83031       {
83032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83033       };
83034     }
83035   }
83036
83037   jresult = result;
83038   return jresult;
83039 }
83040
83041
83042 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetChildAt(void * jarg1, void * jarg2) {
83043   void * jresult ;
83044   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83045   Dali::Toolkit::TableView::CellPosition arg2 ;
83046   Dali::Toolkit::TableView::CellPosition *argp2 ;
83047   Dali::Actor result;
83048
83049   arg1 = (Dali::Toolkit::TableView *)jarg1;
83050   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
83051   if (!argp2) {
83052     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
83053     return 0;
83054   }
83055   arg2 = *argp2;
83056   {
83057     try {
83058       result = (arg1)->GetChildAt(arg2);
83059     } catch (std::out_of_range& e) {
83060       {
83061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83062       };
83063     } catch (std::exception& e) {
83064       {
83065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83066       };
83067     } catch (Dali::DaliException e) {
83068       {
83069         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83070       };
83071     } catch (...) {
83072       {
83073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83074       };
83075     }
83076   }
83077
83078   jresult = new Dali::Actor((const Dali::Actor &)result);
83079   return jresult;
83080 }
83081
83082
83083 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_RemoveChildAt(void * jarg1, void * jarg2) {
83084   void * jresult ;
83085   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83086   Dali::Toolkit::TableView::CellPosition arg2 ;
83087   Dali::Toolkit::TableView::CellPosition *argp2 ;
83088   Dali::Actor result;
83089
83090   arg1 = (Dali::Toolkit::TableView *)jarg1;
83091   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
83092   if (!argp2) {
83093     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
83094     return 0;
83095   }
83096   arg2 = *argp2;
83097   {
83098     try {
83099       result = (arg1)->RemoveChildAt(arg2);
83100     } catch (std::out_of_range& e) {
83101       {
83102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83103       };
83104     } catch (std::exception& e) {
83105       {
83106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83107       };
83108     } catch (Dali::DaliException e) {
83109       {
83110         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83111       };
83112     } catch (...) {
83113       {
83114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83115       };
83116     }
83117   }
83118
83119   jresult = new Dali::Actor((const Dali::Actor &)result);
83120   return jresult;
83121 }
83122
83123
83124 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_FindChildPosition(void * jarg1, void * jarg2, void * jarg3) {
83125   unsigned int jresult ;
83126   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83127   Dali::Actor arg2 ;
83128   Dali::Toolkit::TableView::CellPosition *arg3 = 0 ;
83129   Dali::Actor *argp2 ;
83130   bool result;
83131
83132   arg1 = (Dali::Toolkit::TableView *)jarg1;
83133   argp2 = (Dali::Actor *)jarg2;
83134   if (!argp2) {
83135     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83136     return 0;
83137   }
83138   arg2 = *argp2;
83139   arg3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
83140   if (!arg3) {
83141     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView::CellPosition & type is null", 0);
83142     return 0;
83143   }
83144   {
83145     try {
83146       result = (bool)(arg1)->FindChildPosition(arg2,*arg3);
83147     } catch (std::out_of_range& e) {
83148       {
83149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83150       };
83151     } catch (std::exception& e) {
83152       {
83153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83154       };
83155     } catch (Dali::DaliException e) {
83156       {
83157         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83158       };
83159     } catch (...) {
83160       {
83161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83162       };
83163     }
83164   }
83165
83166   jresult = result;
83167   return jresult;
83168 }
83169
83170
83171 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertRow(void * jarg1, unsigned int jarg2) {
83172   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83173   unsigned int arg2 ;
83174
83175   arg1 = (Dali::Toolkit::TableView *)jarg1;
83176   arg2 = (unsigned int)jarg2;
83177   {
83178     try {
83179       (arg1)->InsertRow(arg2);
83180     } catch (std::out_of_range& e) {
83181       {
83182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83183       };
83184     } catch (std::exception& e) {
83185       {
83186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83187       };
83188     } catch (Dali::DaliException e) {
83189       {
83190         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83191       };
83192     } catch (...) {
83193       {
83194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83195       };
83196     }
83197   }
83198
83199 }
83200
83201
83202 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_0(void * jarg1, unsigned int jarg2) {
83203   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83204   unsigned int arg2 ;
83205
83206   arg1 = (Dali::Toolkit::TableView *)jarg1;
83207   arg2 = (unsigned int)jarg2;
83208   {
83209     try {
83210       (arg1)->DeleteRow(arg2);
83211     } catch (std::out_of_range& e) {
83212       {
83213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83214       };
83215     } catch (std::exception& e) {
83216       {
83217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83218       };
83219     } catch (Dali::DaliException e) {
83220       {
83221         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83222       };
83223     } catch (...) {
83224       {
83225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83226       };
83227     }
83228   }
83229
83230 }
83231
83232
83233 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
83234   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83235   unsigned int arg2 ;
83236   std::vector< Dali::Actor > *arg3 = 0 ;
83237
83238   arg1 = (Dali::Toolkit::TableView *)jarg1;
83239   arg2 = (unsigned int)jarg2;
83240   arg3 = (std::vector< Dali::Actor > *)jarg3;
83241   if (!arg3) {
83242     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
83243     return ;
83244   }
83245   {
83246     try {
83247       (arg1)->DeleteRow(arg2,*arg3);
83248     } catch (std::out_of_range& e) {
83249       {
83250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83251       };
83252     } catch (std::exception& e) {
83253       {
83254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83255       };
83256     } catch (Dali::DaliException e) {
83257       {
83258         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83259       };
83260     } catch (...) {
83261       {
83262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83263       };
83264     }
83265   }
83266
83267 }
83268
83269
83270 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertColumn(void * jarg1, unsigned int jarg2) {
83271   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83272   unsigned int arg2 ;
83273
83274   arg1 = (Dali::Toolkit::TableView *)jarg1;
83275   arg2 = (unsigned int)jarg2;
83276   {
83277     try {
83278       (arg1)->InsertColumn(arg2);
83279     } catch (std::out_of_range& e) {
83280       {
83281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83282       };
83283     } catch (std::exception& e) {
83284       {
83285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83286       };
83287     } catch (Dali::DaliException e) {
83288       {
83289         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83290       };
83291     } catch (...) {
83292       {
83293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83294       };
83295     }
83296   }
83297
83298 }
83299
83300
83301 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_0(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)->DeleteColumn(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 void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
83333   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83334   unsigned int arg2 ;
83335   std::vector< Dali::Actor > *arg3 = 0 ;
83336
83337   arg1 = (Dali::Toolkit::TableView *)jarg1;
83338   arg2 = (unsigned int)jarg2;
83339   arg3 = (std::vector< Dali::Actor > *)jarg3;
83340   if (!arg3) {
83341     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
83342     return ;
83343   }
83344   {
83345     try {
83346       (arg1)->DeleteColumn(arg2,*arg3);
83347     } catch (std::out_of_range& e) {
83348       {
83349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83350       };
83351     } catch (std::exception& e) {
83352       {
83353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83354       };
83355     } catch (Dali::DaliException e) {
83356       {
83357         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83358       };
83359     } catch (...) {
83360       {
83361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83362       };
83363     }
83364   }
83365
83366 }
83367
83368
83369 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_0(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
83370   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83371   unsigned int arg2 ;
83372   unsigned int arg3 ;
83373
83374   arg1 = (Dali::Toolkit::TableView *)jarg1;
83375   arg2 = (unsigned int)jarg2;
83376   arg3 = (unsigned int)jarg3;
83377   {
83378     try {
83379       (arg1)->Resize(arg2,arg3);
83380     } catch (std::out_of_range& e) {
83381       {
83382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83383       };
83384     } catch (std::exception& e) {
83385       {
83386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83387       };
83388     } catch (Dali::DaliException e) {
83389       {
83390         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83391       };
83392     } catch (...) {
83393       {
83394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83395       };
83396     }
83397   }
83398
83399 }
83400
83401
83402 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3, void * jarg4) {
83403   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83404   unsigned int arg2 ;
83405   unsigned int arg3 ;
83406   std::vector< Dali::Actor > *arg4 = 0 ;
83407
83408   arg1 = (Dali::Toolkit::TableView *)jarg1;
83409   arg2 = (unsigned int)jarg2;
83410   arg3 = (unsigned int)jarg3;
83411   arg4 = (std::vector< Dali::Actor > *)jarg4;
83412   if (!arg4) {
83413     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
83414     return ;
83415   }
83416   {
83417     try {
83418       (arg1)->Resize(arg2,arg3,*arg4);
83419     } catch (std::out_of_range& e) {
83420       {
83421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83422       };
83423     } catch (std::exception& e) {
83424       {
83425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83426       };
83427     } catch (Dali::DaliException e) {
83428       {
83429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83430       };
83431     } catch (...) {
83432       {
83433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83434       };
83435     }
83436   }
83437
83438 }
83439
83440
83441 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellPadding(void * jarg1, void * jarg2) {
83442   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83443   Dali::Size arg2 ;
83444   Dali::Size *argp2 ;
83445
83446   arg1 = (Dali::Toolkit::TableView *)jarg1;
83447   argp2 = (Dali::Size *)jarg2;
83448   if (!argp2) {
83449     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
83450     return ;
83451   }
83452   arg2 = *argp2;
83453   {
83454     try {
83455       (arg1)->SetCellPadding(arg2);
83456     } catch (std::out_of_range& e) {
83457       {
83458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83459       };
83460     } catch (std::exception& e) {
83461       {
83462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83463       };
83464     } catch (Dali::DaliException e) {
83465       {
83466         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83467       };
83468     } catch (...) {
83469       {
83470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83471       };
83472     }
83473   }
83474
83475 }
83476
83477
83478 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetCellPadding(void * jarg1) {
83479   void * jresult ;
83480   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83481   Dali::Size result;
83482
83483   arg1 = (Dali::Toolkit::TableView *)jarg1;
83484   {
83485     try {
83486       result = (arg1)->GetCellPadding();
83487     } catch (std::out_of_range& e) {
83488       {
83489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83490       };
83491     } catch (std::exception& e) {
83492       {
83493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83494       };
83495     } catch (Dali::DaliException e) {
83496       {
83497         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83498       };
83499     } catch (...) {
83500       {
83501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83502       };
83503     }
83504   }
83505
83506   jresult = new Dali::Size((const Dali::Size &)result);
83507   return jresult;
83508 }
83509
83510
83511 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitHeight(void * jarg1, unsigned int jarg2) {
83512   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83513   unsigned int arg2 ;
83514
83515   arg1 = (Dali::Toolkit::TableView *)jarg1;
83516   arg2 = (unsigned int)jarg2;
83517   {
83518     try {
83519       (arg1)->SetFitHeight(arg2);
83520     } catch (std::out_of_range& e) {
83521       {
83522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83523       };
83524     } catch (std::exception& e) {
83525       {
83526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83527       };
83528     } catch (Dali::DaliException e) {
83529       {
83530         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83531       };
83532     } catch (...) {
83533       {
83534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83535       };
83536     }
83537   }
83538
83539 }
83540
83541
83542 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitHeight(void * jarg1, unsigned int jarg2) {
83543   unsigned int jresult ;
83544   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83545   unsigned int arg2 ;
83546   bool result;
83547
83548   arg1 = (Dali::Toolkit::TableView *)jarg1;
83549   arg2 = (unsigned int)jarg2;
83550   {
83551     try {
83552       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitHeight(arg2);
83553     } catch (std::out_of_range& e) {
83554       {
83555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83556       };
83557     } catch (std::exception& e) {
83558       {
83559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83560       };
83561     } catch (Dali::DaliException e) {
83562       {
83563         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83564       };
83565     } catch (...) {
83566       {
83567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83568       };
83569     }
83570   }
83571
83572   jresult = result;
83573   return jresult;
83574 }
83575
83576
83577 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitWidth(void * jarg1, unsigned int jarg2) {
83578   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83579   unsigned int arg2 ;
83580
83581   arg1 = (Dali::Toolkit::TableView *)jarg1;
83582   arg2 = (unsigned int)jarg2;
83583   {
83584     try {
83585       (arg1)->SetFitWidth(arg2);
83586     } catch (std::out_of_range& e) {
83587       {
83588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83589       };
83590     } catch (std::exception& e) {
83591       {
83592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83593       };
83594     } catch (Dali::DaliException e) {
83595       {
83596         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83597       };
83598     } catch (...) {
83599       {
83600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83601       };
83602     }
83603   }
83604
83605 }
83606
83607
83608 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitWidth(void * jarg1, unsigned int jarg2) {
83609   unsigned int jresult ;
83610   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83611   unsigned int arg2 ;
83612   bool result;
83613
83614   arg1 = (Dali::Toolkit::TableView *)jarg1;
83615   arg2 = (unsigned int)jarg2;
83616   {
83617     try {
83618       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitWidth(arg2);
83619     } catch (std::out_of_range& e) {
83620       {
83621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83622       };
83623     } catch (std::exception& e) {
83624       {
83625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83626       };
83627     } catch (Dali::DaliException e) {
83628       {
83629         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83630       };
83631     } catch (...) {
83632       {
83633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83634       };
83635     }
83636   }
83637
83638   jresult = result;
83639   return jresult;
83640 }
83641
83642
83643 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedHeight(void * jarg1, unsigned int jarg2, float jarg3) {
83644   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83645   unsigned int arg2 ;
83646   float arg3 ;
83647
83648   arg1 = (Dali::Toolkit::TableView *)jarg1;
83649   arg2 = (unsigned int)jarg2;
83650   arg3 = (float)jarg3;
83651   {
83652     try {
83653       (arg1)->SetFixedHeight(arg2,arg3);
83654     } catch (std::out_of_range& e) {
83655       {
83656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83657       };
83658     } catch (std::exception& e) {
83659       {
83660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83661       };
83662     } catch (Dali::DaliException e) {
83663       {
83664         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83665       };
83666     } catch (...) {
83667       {
83668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83669       };
83670     }
83671   }
83672
83673 }
83674
83675
83676 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedHeight(void * jarg1, unsigned int jarg2) {
83677   float jresult ;
83678   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83679   unsigned int arg2 ;
83680   float result;
83681
83682   arg1 = (Dali::Toolkit::TableView *)jarg1;
83683   arg2 = (unsigned int)jarg2;
83684   {
83685     try {
83686       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedHeight(arg2);
83687     } catch (std::out_of_range& e) {
83688       {
83689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83690       };
83691     } catch (std::exception& e) {
83692       {
83693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83694       };
83695     } catch (Dali::DaliException e) {
83696       {
83697         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83698       };
83699     } catch (...) {
83700       {
83701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83702       };
83703     }
83704   }
83705
83706   jresult = result;
83707   return jresult;
83708 }
83709
83710
83711 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeHeight(void * jarg1, unsigned int jarg2, float jarg3) {
83712   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83713   unsigned int arg2 ;
83714   float arg3 ;
83715
83716   arg1 = (Dali::Toolkit::TableView *)jarg1;
83717   arg2 = (unsigned int)jarg2;
83718   arg3 = (float)jarg3;
83719   {
83720     try {
83721       (arg1)->SetRelativeHeight(arg2,arg3);
83722     } catch (std::out_of_range& e) {
83723       {
83724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83725       };
83726     } catch (std::exception& e) {
83727       {
83728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83729       };
83730     } catch (Dali::DaliException e) {
83731       {
83732         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83733       };
83734     } catch (...) {
83735       {
83736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83737       };
83738     }
83739   }
83740
83741 }
83742
83743
83744 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeHeight(void * jarg1, unsigned int jarg2) {
83745   float jresult ;
83746   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83747   unsigned int arg2 ;
83748   float result;
83749
83750   arg1 = (Dali::Toolkit::TableView *)jarg1;
83751   arg2 = (unsigned int)jarg2;
83752   {
83753     try {
83754       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeHeight(arg2);
83755     } catch (std::out_of_range& e) {
83756       {
83757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83758       };
83759     } catch (std::exception& e) {
83760       {
83761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83762       };
83763     } catch (Dali::DaliException e) {
83764       {
83765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83766       };
83767     } catch (...) {
83768       {
83769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83770       };
83771     }
83772   }
83773
83774   jresult = result;
83775   return jresult;
83776 }
83777
83778
83779 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedWidth(void * jarg1, unsigned int jarg2, float jarg3) {
83780   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83781   unsigned int arg2 ;
83782   float arg3 ;
83783
83784   arg1 = (Dali::Toolkit::TableView *)jarg1;
83785   arg2 = (unsigned int)jarg2;
83786   arg3 = (float)jarg3;
83787   {
83788     try {
83789       (arg1)->SetFixedWidth(arg2,arg3);
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 float SWIGSTDCALL CSharp_Dali_TableView_GetFixedWidth(void * jarg1, unsigned int jarg2) {
83813   float jresult ;
83814   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83815   unsigned int arg2 ;
83816   float result;
83817
83818   arg1 = (Dali::Toolkit::TableView *)jarg1;
83819   arg2 = (unsigned int)jarg2;
83820   {
83821     try {
83822       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedWidth(arg2);
83823     } catch (std::out_of_range& e) {
83824       {
83825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83826       };
83827     } catch (std::exception& e) {
83828       {
83829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83830       };
83831     } catch (Dali::DaliException e) {
83832       {
83833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83834       };
83835     } catch (...) {
83836       {
83837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83838       };
83839     }
83840   }
83841
83842   jresult = result;
83843   return jresult;
83844 }
83845
83846
83847 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeWidth(void * jarg1, unsigned int jarg2, float jarg3) {
83848   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83849   unsigned int arg2 ;
83850   float arg3 ;
83851
83852   arg1 = (Dali::Toolkit::TableView *)jarg1;
83853   arg2 = (unsigned int)jarg2;
83854   arg3 = (float)jarg3;
83855   {
83856     try {
83857       (arg1)->SetRelativeWidth(arg2,arg3);
83858     } catch (std::out_of_range& e) {
83859       {
83860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83861       };
83862     } catch (std::exception& e) {
83863       {
83864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83865       };
83866     } catch (Dali::DaliException e) {
83867       {
83868         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83869       };
83870     } catch (...) {
83871       {
83872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83873       };
83874     }
83875   }
83876
83877 }
83878
83879
83880 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeWidth(void * jarg1, unsigned int jarg2) {
83881   float jresult ;
83882   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83883   unsigned int arg2 ;
83884   float result;
83885
83886   arg1 = (Dali::Toolkit::TableView *)jarg1;
83887   arg2 = (unsigned int)jarg2;
83888   {
83889     try {
83890       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeWidth(arg2);
83891     } catch (std::out_of_range& e) {
83892       {
83893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83894       };
83895     } catch (std::exception& e) {
83896       {
83897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83898       };
83899     } catch (Dali::DaliException e) {
83900       {
83901         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83902       };
83903     } catch (...) {
83904       {
83905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83906       };
83907     }
83908   }
83909
83910   jresult = result;
83911   return jresult;
83912 }
83913
83914
83915 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetRows(void * jarg1) {
83916   unsigned int jresult ;
83917   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83918   unsigned int result;
83919
83920   arg1 = (Dali::Toolkit::TableView *)jarg1;
83921   {
83922     try {
83923       result = (unsigned int)(arg1)->GetRows();
83924     } catch (std::out_of_range& e) {
83925       {
83926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83927       };
83928     } catch (std::exception& e) {
83929       {
83930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83931       };
83932     } catch (Dali::DaliException e) {
83933       {
83934         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83935       };
83936     } catch (...) {
83937       {
83938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83939       };
83940     }
83941   }
83942
83943   jresult = result;
83944   return jresult;
83945 }
83946
83947
83948 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetColumns(void * jarg1) {
83949   unsigned int jresult ;
83950   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83951   unsigned int result;
83952
83953   arg1 = (Dali::Toolkit::TableView *)jarg1;
83954   {
83955     try {
83956       result = (unsigned int)(arg1)->GetColumns();
83957     } catch (std::out_of_range& e) {
83958       {
83959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83960       };
83961     } catch (std::exception& e) {
83962       {
83963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83964       };
83965     } catch (Dali::DaliException e) {
83966       {
83967         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83968       };
83969     } catch (...) {
83970       {
83971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83972       };
83973     }
83974   }
83975
83976   jresult = result;
83977   return jresult;
83978 }
83979
83980
83981 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellAlignment(void * jarg1, void * jarg2, int jarg3, int jarg4) {
83982   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83983   Dali::Toolkit::TableView::CellPosition arg2 ;
83984   Dali::HorizontalAlignment::Type arg3 ;
83985   Dali::VerticalAlignment::Type arg4 ;
83986   Dali::Toolkit::TableView::CellPosition *argp2 ;
83987
83988   arg1 = (Dali::Toolkit::TableView *)jarg1;
83989   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
83990   if (!argp2) {
83991     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
83992     return ;
83993   }
83994   arg2 = *argp2;
83995   arg3 = (Dali::HorizontalAlignment::Type)jarg3;
83996   arg4 = (Dali::VerticalAlignment::Type)jarg4;
83997   {
83998     try {
83999       (arg1)->SetCellAlignment(arg2,arg3,arg4);
84000     } catch (std::out_of_range& e) {
84001       {
84002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84003       };
84004     } catch (std::exception& e) {
84005       {
84006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84007       };
84008     } catch (Dali::DaliException e) {
84009       {
84010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84011       };
84012     } catch (...) {
84013       {
84014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84015       };
84016     }
84017   }
84018
84019 }
84020
84021
84022 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DEFAULT_RENDERING_BACKEND_get() {
84023   unsigned int jresult ;
84024   unsigned int result;
84025
84026   result = (unsigned int)(unsigned int)Dali::Toolkit::Text::DEFAULT_RENDERING_BACKEND;
84027   jresult = result;
84028   return jresult;
84029 }
84030
84031
84032 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_RENDERING_BACKEND_get() {
84033   int jresult ;
84034   int result;
84035
84036   result = (int)Dali::Toolkit::TextLabel::Property::RENDERING_BACKEND;
84037   jresult = (int)result;
84038   return jresult;
84039 }
84040
84041
84042 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_get() {
84043   int jresult ;
84044   int result;
84045
84046   result = (int)Dali::Toolkit::TextLabel::Property::TEXT;
84047   jresult = (int)result;
84048   return jresult;
84049 }
84050
84051
84052 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_FAMILY_get() {
84053   int jresult ;
84054   int result;
84055
84056   result = (int)Dali::Toolkit::TextLabel::Property::FONT_FAMILY;
84057   jresult = (int)result;
84058   return jresult;
84059 }
84060
84061
84062 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_STYLE_get() {
84063   int jresult ;
84064   int result;
84065
84066   result = (int)Dali::Toolkit::TextLabel::Property::FONT_STYLE;
84067   jresult = (int)result;
84068   return jresult;
84069 }
84070
84071
84072 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_POINT_SIZE_get() {
84073   int jresult ;
84074   int result;
84075
84076   result = (int)Dali::Toolkit::TextLabel::Property::POINT_SIZE;
84077   jresult = (int)result;
84078   return jresult;
84079 }
84080
84081
84082 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_MULTI_LINE_get() {
84083   int jresult ;
84084   int result;
84085
84086   result = (int)Dali::Toolkit::TextLabel::Property::MULTI_LINE;
84087   jresult = (int)result;
84088   return jresult;
84089 }
84090
84091
84092 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_HORIZONTAL_ALIGNMENT_get() {
84093   int jresult ;
84094   int result;
84095
84096   result = (int)Dali::Toolkit::TextLabel::Property::HORIZONTAL_ALIGNMENT;
84097   jresult = (int)result;
84098   return jresult;
84099 }
84100
84101
84102 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_VERTICAL_ALIGNMENT_get() {
84103   int jresult ;
84104   int result;
84105
84106   result = (int)Dali::Toolkit::TextLabel::Property::VERTICAL_ALIGNMENT;
84107   jresult = (int)result;
84108   return jresult;
84109 }
84110
84111
84112 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_COLOR_get() {
84113   int jresult ;
84114   int result;
84115
84116   result = (int)Dali::Toolkit::TextLabel::Property::TEXT_COLOR;
84117   jresult = (int)result;
84118   return jresult;
84119 }
84120
84121
84122 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_MARKUP_get() {
84123   int jresult ;
84124   int result;
84125
84126   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_MARKUP;
84127   jresult = (int)result;
84128   return jresult;
84129 }
84130
84131
84132 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_AUTO_SCROLL_get() {
84133   int jresult ;
84134   int result;
84135
84136   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_AUTO_SCROLL;
84137   jresult = (int)result;
84138   return jresult;
84139 }
84140
84141
84142 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_SPEED_get() {
84143   int jresult ;
84144   int result;
84145
84146   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_SPEED;
84147   jresult = (int)result;
84148   return jresult;
84149 }
84150
84151
84152 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_LOOP_COUNT_get() {
84153   int jresult ;
84154   int result;
84155
84156   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_LOOP_COUNT;
84157   jresult = (int)result;
84158   return jresult;
84159 }
84160
84161
84162 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_GAP_get() {
84163   int jresult ;
84164   int result;
84165
84166   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_GAP;
84167   jresult = (int)result;
84168   return jresult;
84169 }
84170
84171
84172 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_LINE_SPACING_get() {
84173   int jresult ;
84174   int result;
84175
84176   result = (int)Dali::Toolkit::TextLabel::Property::LINE_SPACING;
84177   jresult = (int)result;
84178   return jresult;
84179 }
84180
84181
84182 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_get() {
84183   int jresult ;
84184   int result;
84185
84186   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE;
84187   jresult = (int)result;
84188   return jresult;
84189 }
84190
84191
84192 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_get() {
84193   int jresult ;
84194   int result;
84195
84196   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW;
84197   jresult = (int)result;
84198   return jresult;
84199 }
84200
84201
84202 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_EMBOSS_get() {
84203   int jresult ;
84204   int result;
84205
84206   result = (int)Dali::Toolkit::TextLabel::Property::EMBOSS;
84207   jresult = (int)result;
84208   return jresult;
84209 }
84210
84211
84212 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_OUTLINE_get() {
84213   int jresult ;
84214   int result;
84215
84216   result = (int)Dali::Toolkit::TextLabel::Property::OUTLINE;
84217   jresult = (int)result;
84218   return jresult;
84219 }
84220
84221
84222 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel_Property() {
84223   void * jresult ;
84224   Dali::Toolkit::TextLabel::Property *result = 0 ;
84225
84226   {
84227     try {
84228       result = (Dali::Toolkit::TextLabel::Property *)new Dali::Toolkit::TextLabel::Property();
84229     } catch (std::out_of_range& e) {
84230       {
84231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84232       };
84233     } catch (std::exception& e) {
84234       {
84235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84236       };
84237     } catch (Dali::DaliException e) {
84238       {
84239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84240       };
84241     } catch (...) {
84242       {
84243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84244       };
84245     }
84246   }
84247
84248   jresult = (void *)result;
84249   return jresult;
84250 }
84251
84252
84253 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel_Property(void * jarg1) {
84254   Dali::Toolkit::TextLabel::Property *arg1 = (Dali::Toolkit::TextLabel::Property *) 0 ;
84255
84256   arg1 = (Dali::Toolkit::TextLabel::Property *)jarg1;
84257   {
84258     try {
84259       delete arg1;
84260     } catch (std::out_of_range& e) {
84261       {
84262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84263       };
84264     } catch (std::exception& e) {
84265       {
84266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84267       };
84268     } catch (Dali::DaliException e) {
84269       {
84270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84271       };
84272     } catch (...) {
84273       {
84274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84275       };
84276     }
84277   }
84278
84279 }
84280
84281
84282 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_0() {
84283   void * jresult ;
84284   Dali::Toolkit::TextLabel result;
84285
84286   {
84287     try {
84288       result = Dali::Toolkit::TextLabel::New();
84289     } catch (std::out_of_range& e) {
84290       {
84291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84292       };
84293     } catch (std::exception& e) {
84294       {
84295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84296       };
84297     } catch (Dali::DaliException e) {
84298       {
84299         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84300       };
84301     } catch (...) {
84302       {
84303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84304       };
84305     }
84306   }
84307
84308   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
84309   return jresult;
84310 }
84311
84312
84313 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_1(char * jarg1) {
84314   void * jresult ;
84315   std::string *arg1 = 0 ;
84316   Dali::Toolkit::TextLabel result;
84317
84318   if (!jarg1) {
84319     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
84320     return 0;
84321   }
84322   std::string arg1_str(jarg1);
84323   arg1 = &arg1_str;
84324   {
84325     try {
84326       result = Dali::Toolkit::TextLabel::New((std::string const &)*arg1);
84327     } catch (std::out_of_range& e) {
84328       {
84329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84330       };
84331     } catch (std::exception& e) {
84332       {
84333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84334       };
84335     } catch (Dali::DaliException e) {
84336       {
84337         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84338       };
84339     } catch (...) {
84340       {
84341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84342       };
84343     }
84344   }
84345
84346   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
84347
84348   //argout typemap for const std::string&
84349
84350   return jresult;
84351 }
84352
84353
84354 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_0() {
84355   void * jresult ;
84356   Dali::Toolkit::TextLabel *result = 0 ;
84357
84358   {
84359     try {
84360       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel();
84361     } catch (std::out_of_range& e) {
84362       {
84363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84364       };
84365     } catch (std::exception& e) {
84366       {
84367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84368       };
84369     } catch (Dali::DaliException e) {
84370       {
84371         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84372       };
84373     } catch (...) {
84374       {
84375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84376       };
84377     }
84378   }
84379
84380   jresult = (void *)result;
84381   return jresult;
84382 }
84383
84384
84385 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_1(void * jarg1) {
84386   void * jresult ;
84387   Dali::Toolkit::TextLabel *arg1 = 0 ;
84388   Dali::Toolkit::TextLabel *result = 0 ;
84389
84390   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
84391   if (!arg1) {
84392     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
84393     return 0;
84394   }
84395   {
84396     try {
84397       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel((Dali::Toolkit::TextLabel const &)*arg1);
84398     } catch (std::out_of_range& e) {
84399       {
84400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84401       };
84402     } catch (std::exception& e) {
84403       {
84404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84405       };
84406     } catch (Dali::DaliException e) {
84407       {
84408         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84409       };
84410     } catch (...) {
84411       {
84412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84413       };
84414     }
84415   }
84416
84417   jresult = (void *)result;
84418   return jresult;
84419 }
84420
84421
84422 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_Assign(void * jarg1, void * jarg2) {
84423   void * jresult ;
84424   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
84425   Dali::Toolkit::TextLabel *arg2 = 0 ;
84426   Dali::Toolkit::TextLabel *result = 0 ;
84427
84428   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
84429   arg2 = (Dali::Toolkit::TextLabel *)jarg2;
84430   if (!arg2) {
84431     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
84432     return 0;
84433   }
84434   {
84435     try {
84436       result = (Dali::Toolkit::TextLabel *) &(arg1)->operator =((Dali::Toolkit::TextLabel const &)*arg2);
84437     } catch (std::out_of_range& e) {
84438       {
84439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84440       };
84441     } catch (std::exception& e) {
84442       {
84443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84444       };
84445     } catch (Dali::DaliException e) {
84446       {
84447         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84448       };
84449     } catch (...) {
84450       {
84451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84452       };
84453     }
84454   }
84455
84456   jresult = (void *)result;
84457   return jresult;
84458 }
84459
84460
84461 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel(void * jarg1) {
84462   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
84463
84464   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
84465   {
84466     try {
84467       delete arg1;
84468     } catch (std::out_of_range& e) {
84469       {
84470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84471       };
84472     } catch (std::exception& e) {
84473       {
84474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84475       };
84476     } catch (Dali::DaliException e) {
84477       {
84478         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84479       };
84480     } catch (...) {
84481       {
84482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84483       };
84484     }
84485   }
84486
84487 }
84488
84489
84490 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_DownCast(void * jarg1) {
84491   void * jresult ;
84492   Dali::BaseHandle arg1 ;
84493   Dali::BaseHandle *argp1 ;
84494   Dali::Toolkit::TextLabel result;
84495
84496   argp1 = (Dali::BaseHandle *)jarg1;
84497   if (!argp1) {
84498     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
84499     return 0;
84500   }
84501   arg1 = *argp1;
84502   {
84503     try {
84504       result = Dali::Toolkit::TextLabel::DownCast(arg1);
84505     } catch (std::out_of_range& e) {
84506       {
84507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84508       };
84509     } catch (std::exception& e) {
84510       {
84511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84512       };
84513     } catch (Dali::DaliException e) {
84514       {
84515         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84516       };
84517     } catch (...) {
84518       {
84519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84520       };
84521     }
84522   }
84523
84524   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
84525   return jresult;
84526 }
84527
84528
84529 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityManager() {
84530   void * jresult ;
84531   Dali::Toolkit::AccessibilityManager *result = 0 ;
84532
84533   {
84534     try {
84535       result = (Dali::Toolkit::AccessibilityManager *)new Dali::Toolkit::AccessibilityManager();
84536     } catch (std::out_of_range& e) {
84537       {
84538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84539       };
84540     } catch (std::exception& e) {
84541       {
84542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84543       };
84544     } catch (Dali::DaliException e) {
84545       {
84546         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84547       };
84548     } catch (...) {
84549       {
84550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84551       };
84552     }
84553   }
84554
84555   jresult = (void *)result;
84556   return jresult;
84557 }
84558
84559
84560 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityManager(void * jarg1) {
84561   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84562
84563   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84564   {
84565     try {
84566       delete arg1;
84567     } catch (std::out_of_range& e) {
84568       {
84569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84570       };
84571     } catch (std::exception& e) {
84572       {
84573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84574       };
84575     } catch (Dali::DaliException e) {
84576       {
84577         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84578       };
84579     } catch (...) {
84580       {
84581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84582       };
84583     }
84584   }
84585
84586 }
84587
84588
84589 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_Get() {
84590   void * jresult ;
84591   Dali::Toolkit::AccessibilityManager result;
84592
84593   {
84594     try {
84595       result = Dali::Toolkit::AccessibilityManager::Get();
84596     } catch (std::out_of_range& e) {
84597       {
84598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84599       };
84600     } catch (std::exception& e) {
84601       {
84602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84603       };
84604     } catch (Dali::DaliException e) {
84605       {
84606         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84607       };
84608     } catch (...) {
84609       {
84610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84611       };
84612     }
84613   }
84614
84615   jresult = new Dali::Toolkit::AccessibilityManager((const Dali::Toolkit::AccessibilityManager &)result);
84616   return jresult;
84617 }
84618
84619
84620 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3, char * jarg4) {
84621   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84622   Dali::Actor arg2 ;
84623   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
84624   std::string *arg4 = 0 ;
84625   Dali::Actor *argp2 ;
84626
84627   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84628   argp2 = (Dali::Actor *)jarg2;
84629   if (!argp2) {
84630     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84631     return ;
84632   }
84633   arg2 = *argp2;
84634   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
84635   if (!jarg4) {
84636     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
84637     return ;
84638   }
84639   std::string arg4_str(jarg4);
84640   arg4 = &arg4_str;
84641   {
84642     try {
84643       (arg1)->SetAccessibilityAttribute(arg2,arg3,(std::string const &)*arg4);
84644     } catch (std::out_of_range& e) {
84645       {
84646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84647       };
84648     } catch (std::exception& e) {
84649       {
84650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84651       };
84652     } catch (Dali::DaliException e) {
84653       {
84654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84655       };
84656     } catch (...) {
84657       {
84658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84659       };
84660     }
84661   }
84662
84663
84664   //argout typemap for const std::string&
84665
84666 }
84667
84668
84669 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3) {
84670   char * jresult ;
84671   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84672   Dali::Actor arg2 ;
84673   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
84674   Dali::Actor *argp2 ;
84675   std::string result;
84676
84677   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84678   argp2 = (Dali::Actor *)jarg2;
84679   if (!argp2) {
84680     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84681     return 0;
84682   }
84683   arg2 = *argp2;
84684   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
84685   {
84686     try {
84687       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetAccessibilityAttribute(arg2,arg3);
84688     } catch (std::out_of_range& e) {
84689       {
84690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84691       };
84692     } catch (std::exception& e) {
84693       {
84694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84695       };
84696     } catch (Dali::DaliException e) {
84697       {
84698         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84699       };
84700     } catch (...) {
84701       {
84702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84703       };
84704     }
84705   }
84706
84707   jresult = SWIG_csharp_string_callback((&result)->c_str());
84708   return jresult;
84709 }
84710
84711
84712 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusOrder(void * jarg1, void * jarg2, unsigned int jarg3) {
84713   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84714   Dali::Actor arg2 ;
84715   unsigned int arg3 ;
84716   Dali::Actor *argp2 ;
84717
84718   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84719   argp2 = (Dali::Actor *)jarg2;
84720   if (!argp2) {
84721     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84722     return ;
84723   }
84724   arg2 = *argp2;
84725   arg3 = (unsigned int)jarg3;
84726   {
84727     try {
84728       (arg1)->SetFocusOrder(arg2,arg3);
84729     } catch (std::out_of_range& e) {
84730       {
84731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84732       };
84733     } catch (std::exception& e) {
84734       {
84735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84736       };
84737     } catch (Dali::DaliException e) {
84738       {
84739         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84740       };
84741     } catch (...) {
84742       {
84743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84744       };
84745     }
84746   }
84747
84748 }
84749
84750
84751 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusOrder(void * jarg1, void * jarg2) {
84752   unsigned int jresult ;
84753   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84754   Dali::Actor arg2 ;
84755   Dali::Actor *argp2 ;
84756   unsigned int result;
84757
84758   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84759   argp2 = (Dali::Actor *)jarg2;
84760   if (!argp2) {
84761     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84762     return 0;
84763   }
84764   arg2 = *argp2;
84765   {
84766     try {
84767       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetFocusOrder(arg2);
84768     } catch (std::out_of_range& e) {
84769       {
84770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84771       };
84772     } catch (std::exception& e) {
84773       {
84774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84775       };
84776     } catch (Dali::DaliException e) {
84777       {
84778         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84779       };
84780     } catch (...) {
84781       {
84782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84783       };
84784     }
84785   }
84786
84787   jresult = result;
84788   return jresult;
84789 }
84790
84791
84792 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GenerateNewFocusOrder(void * jarg1) {
84793   unsigned int jresult ;
84794   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84795   unsigned int result;
84796
84797   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84798   {
84799     try {
84800       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GenerateNewFocusOrder();
84801     } catch (std::out_of_range& e) {
84802       {
84803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84804       };
84805     } catch (std::exception& e) {
84806       {
84807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84808       };
84809     } catch (Dali::DaliException e) {
84810       {
84811         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84812       };
84813     } catch (...) {
84814       {
84815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84816       };
84817     }
84818   }
84819
84820   jresult = result;
84821   return jresult;
84822 }
84823
84824
84825 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetActorByFocusOrder(void * jarg1, unsigned int jarg2) {
84826   void * jresult ;
84827   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84828   unsigned int arg2 ;
84829   Dali::Actor result;
84830
84831   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84832   arg2 = (unsigned int)jarg2;
84833   {
84834     try {
84835       result = (arg1)->GetActorByFocusOrder(arg2);
84836     } catch (std::out_of_range& e) {
84837       {
84838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84839       };
84840     } catch (std::exception& e) {
84841       {
84842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84843       };
84844     } catch (Dali::DaliException e) {
84845       {
84846         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84847       };
84848     } catch (...) {
84849       {
84850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84851       };
84852     }
84853   }
84854
84855   jresult = new Dali::Actor((const Dali::Actor &)result);
84856   return jresult;
84857 }
84858
84859
84860 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetCurrentFocusActor(void * jarg1, void * jarg2) {
84861   unsigned int jresult ;
84862   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84863   Dali::Actor arg2 ;
84864   Dali::Actor *argp2 ;
84865   bool result;
84866
84867   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84868   argp2 = (Dali::Actor *)jarg2;
84869   if (!argp2) {
84870     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84871     return 0;
84872   }
84873   arg2 = *argp2;
84874   {
84875     try {
84876       result = (bool)(arg1)->SetCurrentFocusActor(arg2);
84877     } catch (std::out_of_range& e) {
84878       {
84879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84880       };
84881     } catch (std::exception& e) {
84882       {
84883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84884       };
84885     } catch (Dali::DaliException e) {
84886       {
84887         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84888       };
84889     } catch (...) {
84890       {
84891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84892       };
84893     }
84894   }
84895
84896   jresult = result;
84897   return jresult;
84898 }
84899
84900
84901 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusActor(void * jarg1) {
84902   void * jresult ;
84903   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84904   Dali::Actor result;
84905
84906   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84907   {
84908     try {
84909       result = (arg1)->GetCurrentFocusActor();
84910     } catch (std::out_of_range& e) {
84911       {
84912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84913       };
84914     } catch (std::exception& e) {
84915       {
84916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84917       };
84918     } catch (Dali::DaliException e) {
84919       {
84920         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84921       };
84922     } catch (...) {
84923       {
84924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84925       };
84926     }
84927   }
84928
84929   jresult = new Dali::Actor((const Dali::Actor &)result);
84930   return jresult;
84931 }
84932
84933
84934 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusGroup(void * jarg1) {
84935   void * jresult ;
84936   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84937   Dali::Actor result;
84938
84939   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84940   {
84941     try {
84942       result = (arg1)->GetCurrentFocusGroup();
84943     } catch (std::out_of_range& e) {
84944       {
84945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84946       };
84947     } catch (std::exception& e) {
84948       {
84949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84950       };
84951     } catch (Dali::DaliException e) {
84952       {
84953         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84954       };
84955     } catch (...) {
84956       {
84957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84958       };
84959     }
84960   }
84961
84962   jresult = new Dali::Actor((const Dali::Actor &)result);
84963   return jresult;
84964 }
84965
84966
84967 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusOrder(void * jarg1) {
84968   unsigned int jresult ;
84969   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84970   unsigned int result;
84971
84972   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84973   {
84974     try {
84975       result = (unsigned int)(arg1)->GetCurrentFocusOrder();
84976     } catch (std::out_of_range& e) {
84977       {
84978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84979       };
84980     } catch (std::exception& e) {
84981       {
84982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84983       };
84984     } catch (Dali::DaliException e) {
84985       {
84986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84987       };
84988     } catch (...) {
84989       {
84990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84991       };
84992     }
84993   }
84994
84995   jresult = result;
84996   return jresult;
84997 }
84998
84999
85000 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusForward(void * jarg1) {
85001   unsigned int jresult ;
85002   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85003   bool result;
85004
85005   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85006   {
85007     try {
85008       result = (bool)(arg1)->MoveFocusForward();
85009     } catch (std::out_of_range& e) {
85010       {
85011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85012       };
85013     } catch (std::exception& e) {
85014       {
85015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85016       };
85017     } catch (Dali::DaliException e) {
85018       {
85019         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85020       };
85021     } catch (...) {
85022       {
85023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85024       };
85025     }
85026   }
85027
85028   jresult = result;
85029   return jresult;
85030 }
85031
85032
85033 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusBackward(void * jarg1) {
85034   unsigned int jresult ;
85035   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85036   bool result;
85037
85038   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85039   {
85040     try {
85041       result = (bool)(arg1)->MoveFocusBackward();
85042     } catch (std::out_of_range& e) {
85043       {
85044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85045       };
85046     } catch (std::exception& e) {
85047       {
85048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85049       };
85050     } catch (Dali::DaliException e) {
85051       {
85052         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85053       };
85054     } catch (...) {
85055       {
85056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85057       };
85058     }
85059   }
85060
85061   jresult = result;
85062   return jresult;
85063 }
85064
85065
85066 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_ClearFocus(void * jarg1) {
85067   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85068
85069   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85070   {
85071     try {
85072       (arg1)->ClearFocus();
85073     } catch (std::out_of_range& e) {
85074       {
85075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85076       };
85077     } catch (std::exception& e) {
85078       {
85079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85080       };
85081     } catch (Dali::DaliException e) {
85082       {
85083         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85084       };
85085     } catch (...) {
85086       {
85087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85088       };
85089     }
85090   }
85091
85092 }
85093
85094
85095 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_Reset(void * jarg1) {
85096   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85097
85098   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85099   {
85100     try {
85101       (arg1)->Reset();
85102     } catch (std::out_of_range& e) {
85103       {
85104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85105       };
85106     } catch (std::exception& e) {
85107       {
85108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85109       };
85110     } catch (Dali::DaliException e) {
85111       {
85112         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85113       };
85114     } catch (...) {
85115       {
85116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85117       };
85118     }
85119   }
85120
85121 }
85122
85123
85124 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusGroup(void * jarg1, void * jarg2, unsigned int jarg3) {
85125   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85126   Dali::Actor arg2 ;
85127   bool arg3 ;
85128   Dali::Actor *argp2 ;
85129
85130   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85131   argp2 = (Dali::Actor *)jarg2;
85132   if (!argp2) {
85133     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85134     return ;
85135   }
85136   arg2 = *argp2;
85137   arg3 = jarg3 ? true : false;
85138   {
85139     try {
85140       (arg1)->SetFocusGroup(arg2,arg3);
85141     } catch (std::out_of_range& e) {
85142       {
85143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85144       };
85145     } catch (std::exception& e) {
85146       {
85147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85148       };
85149     } catch (Dali::DaliException e) {
85150       {
85151         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85152       };
85153     } catch (...) {
85154       {
85155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85156       };
85157     }
85158   }
85159
85160 }
85161
85162
85163 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_IsFocusGroup(void * jarg1, void * jarg2) {
85164   unsigned int jresult ;
85165   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85166   Dali::Actor arg2 ;
85167   Dali::Actor *argp2 ;
85168   bool result;
85169
85170   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85171   argp2 = (Dali::Actor *)jarg2;
85172   if (!argp2) {
85173     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85174     return 0;
85175   }
85176   arg2 = *argp2;
85177   {
85178     try {
85179       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->IsFocusGroup(arg2);
85180     } catch (std::out_of_range& e) {
85181       {
85182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85183       };
85184     } catch (std::exception& e) {
85185       {
85186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85187       };
85188     } catch (Dali::DaliException e) {
85189       {
85190         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85191       };
85192     } catch (...) {
85193       {
85194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85195       };
85196     }
85197   }
85198
85199   jresult = result;
85200   return jresult;
85201 }
85202
85203
85204 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetGroupMode(void * jarg1, unsigned int jarg2) {
85205   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85206   bool arg2 ;
85207
85208   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85209   arg2 = jarg2 ? true : false;
85210   {
85211     try {
85212       (arg1)->SetGroupMode(arg2);
85213     } catch (std::out_of_range& e) {
85214       {
85215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85216       };
85217     } catch (std::exception& e) {
85218       {
85219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85220       };
85221     } catch (Dali::DaliException e) {
85222       {
85223         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85224       };
85225     } catch (...) {
85226       {
85227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85228       };
85229     }
85230   }
85231
85232 }
85233
85234
85235 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetGroupMode(void * jarg1) {
85236   unsigned int jresult ;
85237   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85238   bool result;
85239
85240   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85241   {
85242     try {
85243       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetGroupMode();
85244     } catch (std::out_of_range& e) {
85245       {
85246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85247       };
85248     } catch (std::exception& e) {
85249       {
85250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85251       };
85252     } catch (Dali::DaliException e) {
85253       {
85254         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85255       };
85256     } catch (...) {
85257       {
85258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85259       };
85260     }
85261   }
85262
85263   jresult = result;
85264   return jresult;
85265 }
85266
85267
85268 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetWrapMode(void * jarg1, unsigned int jarg2) {
85269   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85270   bool arg2 ;
85271
85272   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85273   arg2 = jarg2 ? true : false;
85274   {
85275     try {
85276       (arg1)->SetWrapMode(arg2);
85277     } catch (std::out_of_range& e) {
85278       {
85279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85280       };
85281     } catch (std::exception& e) {
85282       {
85283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85284       };
85285     } catch (Dali::DaliException e) {
85286       {
85287         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85288       };
85289     } catch (...) {
85290       {
85291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85292       };
85293     }
85294   }
85295
85296 }
85297
85298
85299 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetWrapMode(void * jarg1) {
85300   unsigned int jresult ;
85301   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85302   bool result;
85303
85304   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85305   {
85306     try {
85307       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetWrapMode();
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 = result;
85328   return jresult;
85329 }
85330
85331
85332 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusIndicatorActor(void * jarg1, void * jarg2) {
85333   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85334   Dali::Actor arg2 ;
85335   Dali::Actor *argp2 ;
85336
85337   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85338   argp2 = (Dali::Actor *)jarg2;
85339   if (!argp2) {
85340     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85341     return ;
85342   }
85343   arg2 = *argp2;
85344   {
85345     try {
85346       (arg1)->SetFocusIndicatorActor(arg2);
85347     } catch (std::out_of_range& e) {
85348       {
85349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85350       };
85351     } catch (std::exception& e) {
85352       {
85353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85354       };
85355     } catch (Dali::DaliException e) {
85356       {
85357         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85358       };
85359     } catch (...) {
85360       {
85361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85362       };
85363     }
85364   }
85365
85366 }
85367
85368
85369 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusIndicatorActor(void * jarg1) {
85370   void * jresult ;
85371   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85372   Dali::Actor result;
85373
85374   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85375   {
85376     try {
85377       result = (arg1)->GetFocusIndicatorActor();
85378     } catch (std::out_of_range& e) {
85379       {
85380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85381       };
85382     } catch (std::exception& e) {
85383       {
85384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85385       };
85386     } catch (Dali::DaliException e) {
85387       {
85388         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85389       };
85390     } catch (...) {
85391       {
85392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85393       };
85394     }
85395   }
85396
85397   jresult = new Dali::Actor((const Dali::Actor &)result);
85398   return jresult;
85399 }
85400
85401
85402 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusGroup(void * jarg1, void * jarg2) {
85403   void * jresult ;
85404   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85405   Dali::Actor arg2 ;
85406   Dali::Actor *argp2 ;
85407   Dali::Actor result;
85408
85409   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85410   argp2 = (Dali::Actor *)jarg2;
85411   if (!argp2) {
85412     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85413     return 0;
85414   }
85415   arg2 = *argp2;
85416   {
85417     try {
85418       result = (arg1)->GetFocusGroup(arg2);
85419     } catch (std::out_of_range& e) {
85420       {
85421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85422       };
85423     } catch (std::exception& e) {
85424       {
85425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85426       };
85427     } catch (Dali::DaliException e) {
85428       {
85429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85430       };
85431     } catch (...) {
85432       {
85433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85434       };
85435     }
85436   }
85437
85438   jresult = new Dali::Actor((const Dali::Actor &)result);
85439   return jresult;
85440 }
85441
85442
85443 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetReadPosition(void * jarg1) {
85444   void * jresult ;
85445   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85446   Dali::Vector2 result;
85447
85448   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85449   {
85450     try {
85451       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetReadPosition();
85452     } catch (std::out_of_range& e) {
85453       {
85454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85455       };
85456     } catch (std::exception& e) {
85457       {
85458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85459       };
85460     } catch (Dali::DaliException e) {
85461       {
85462         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85463       };
85464     } catch (...) {
85465       {
85466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85467       };
85468     }
85469   }
85470
85471   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
85472   return jresult;
85473 }
85474
85475
85476 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusChangedSignal(void * jarg1) {
85477   void * jresult ;
85478   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85479   Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *result = 0 ;
85480
85481   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85482   {
85483     try {
85484       result = (Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *) &(arg1)->FocusChangedSignal();
85485     } catch (std::out_of_range& e) {
85486       {
85487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85488       };
85489     } catch (std::exception& e) {
85490       {
85491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85492       };
85493     } catch (Dali::DaliException e) {
85494       {
85495         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85496       };
85497     } catch (...) {
85498       {
85499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85500       };
85501     }
85502   }
85503
85504   jresult = (void *)result;
85505   return jresult;
85506 }
85507
85508
85509 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusOvershotSignal(void * jarg1) {
85510   void * jresult ;
85511   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85512   Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *result = 0 ;
85513
85514   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85515   {
85516     try {
85517       result = (Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *) &(arg1)->FocusOvershotSignal();
85518     } catch (std::out_of_range& e) {
85519       {
85520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85521       };
85522     } catch (std::exception& e) {
85523       {
85524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85525       };
85526     } catch (Dali::DaliException e) {
85527       {
85528         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85529       };
85530     } catch (...) {
85531       {
85532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85533       };
85534     }
85535   }
85536
85537   jresult = (void *)result;
85538   return jresult;
85539 }
85540
85541
85542 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusedActorActivatedSignal(void * jarg1) {
85543   void * jresult ;
85544   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85545   Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *result = 0 ;
85546
85547   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85548   {
85549     try {
85550       result = (Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *) &(arg1)->FocusedActorActivatedSignal();
85551     } catch (std::out_of_range& e) {
85552       {
85553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85554       };
85555     } catch (std::exception& e) {
85556       {
85557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85558       };
85559     } catch (Dali::DaliException e) {
85560       {
85561         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85562       };
85563     } catch (...) {
85564       {
85565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85566       };
85567     }
85568   }
85569
85570   jresult = (void *)result;
85571   return jresult;
85572 }
85573
85574
85575 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_StatusChangedSignal(void * jarg1) {
85576   void * jresult ;
85577   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85578   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85579
85580   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85581   {
85582     try {
85583       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->StatusChangedSignal();
85584     } catch (std::out_of_range& e) {
85585       {
85586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85587       };
85588     } catch (std::exception& e) {
85589       {
85590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85591       };
85592     } catch (Dali::DaliException e) {
85593       {
85594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85595       };
85596     } catch (...) {
85597       {
85598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85599       };
85600     }
85601   }
85602
85603   jresult = (void *)result;
85604   return jresult;
85605 }
85606
85607
85608 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionNextSignal(void * jarg1) {
85609   void * jresult ;
85610   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85611   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85612
85613   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85614   {
85615     try {
85616       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionNextSignal();
85617     } catch (std::out_of_range& e) {
85618       {
85619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85620       };
85621     } catch (std::exception& e) {
85622       {
85623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85624       };
85625     } catch (Dali::DaliException e) {
85626       {
85627         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85628       };
85629     } catch (...) {
85630       {
85631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85632       };
85633     }
85634   }
85635
85636   jresult = (void *)result;
85637   return jresult;
85638 }
85639
85640
85641 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPreviousSignal(void * jarg1) {
85642   void * jresult ;
85643   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85644   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85645
85646   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85647   {
85648     try {
85649       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPreviousSignal();
85650     } catch (std::out_of_range& e) {
85651       {
85652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85653       };
85654     } catch (std::exception& e) {
85655       {
85656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85657       };
85658     } catch (Dali::DaliException e) {
85659       {
85660         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85661       };
85662     } catch (...) {
85663       {
85664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85665       };
85666     }
85667   }
85668
85669   jresult = (void *)result;
85670   return jresult;
85671 }
85672
85673
85674 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionActivateSignal(void * jarg1) {
85675   void * jresult ;
85676   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85677   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85678
85679   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85680   {
85681     try {
85682       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionActivateSignal();
85683     } catch (std::out_of_range& e) {
85684       {
85685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85686       };
85687     } catch (std::exception& e) {
85688       {
85689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85690       };
85691     } catch (Dali::DaliException e) {
85692       {
85693         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85694       };
85695     } catch (...) {
85696       {
85697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85698       };
85699     }
85700   }
85701
85702   jresult = (void *)result;
85703   return jresult;
85704 }
85705
85706
85707 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadSignal(void * jarg1) {
85708   void * jresult ;
85709   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85710   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85711
85712   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85713   {
85714     try {
85715       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadSignal();
85716     } catch (std::out_of_range& e) {
85717       {
85718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85719       };
85720     } catch (std::exception& e) {
85721       {
85722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85723       };
85724     } catch (Dali::DaliException e) {
85725       {
85726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85727       };
85728     } catch (...) {
85729       {
85730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85731       };
85732     }
85733   }
85734
85735   jresult = (void *)result;
85736   return jresult;
85737 }
85738
85739
85740 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionOverSignal(void * jarg1) {
85741   void * jresult ;
85742   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85743   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85744
85745   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85746   {
85747     try {
85748       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionOverSignal();
85749     } catch (std::out_of_range& e) {
85750       {
85751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85752       };
85753     } catch (std::exception& e) {
85754       {
85755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85756       };
85757     } catch (Dali::DaliException e) {
85758       {
85759         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85760       };
85761     } catch (...) {
85762       {
85763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85764       };
85765     }
85766   }
85767
85768   jresult = (void *)result;
85769   return jresult;
85770 }
85771
85772
85773 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadNextSignal(void * jarg1) {
85774   void * jresult ;
85775   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85776   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85777
85778   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85779   {
85780     try {
85781       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadNextSignal();
85782     } catch (std::out_of_range& e) {
85783       {
85784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85785       };
85786     } catch (std::exception& e) {
85787       {
85788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85789       };
85790     } catch (Dali::DaliException e) {
85791       {
85792         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85793       };
85794     } catch (...) {
85795       {
85796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85797       };
85798     }
85799   }
85800
85801   jresult = (void *)result;
85802   return jresult;
85803 }
85804
85805
85806 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPreviousSignal(void * jarg1) {
85807   void * jresult ;
85808   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85809   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85810
85811   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85812   {
85813     try {
85814       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPreviousSignal();
85815     } catch (std::out_of_range& e) {
85816       {
85817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85818       };
85819     } catch (std::exception& e) {
85820       {
85821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85822       };
85823     } catch (Dali::DaliException e) {
85824       {
85825         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85826       };
85827     } catch (...) {
85828       {
85829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85830       };
85831     }
85832   }
85833
85834   jresult = (void *)result;
85835   return jresult;
85836 }
85837
85838
85839 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionUpSignal(void * jarg1) {
85840   void * jresult ;
85841   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85842   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85843
85844   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85845   {
85846     try {
85847       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionUpSignal();
85848     } catch (std::out_of_range& e) {
85849       {
85850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85851       };
85852     } catch (std::exception& e) {
85853       {
85854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85855       };
85856     } catch (Dali::DaliException e) {
85857       {
85858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85859       };
85860     } catch (...) {
85861       {
85862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85863       };
85864     }
85865   }
85866
85867   jresult = (void *)result;
85868   return jresult;
85869 }
85870
85871
85872 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionDownSignal(void * jarg1) {
85873   void * jresult ;
85874   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85875   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85876
85877   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85878   {
85879     try {
85880       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionDownSignal();
85881     } catch (std::out_of_range& e) {
85882       {
85883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85884       };
85885     } catch (std::exception& e) {
85886       {
85887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85888       };
85889     } catch (Dali::DaliException e) {
85890       {
85891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85892       };
85893     } catch (...) {
85894       {
85895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85896       };
85897     }
85898   }
85899
85900   jresult = (void *)result;
85901   return jresult;
85902 }
85903
85904
85905 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionClearFocusSignal(void * jarg1) {
85906   void * jresult ;
85907   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85908   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85909
85910   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85911   {
85912     try {
85913       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionClearFocusSignal();
85914     } catch (std::out_of_range& e) {
85915       {
85916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85917       };
85918     } catch (std::exception& e) {
85919       {
85920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85921       };
85922     } catch (Dali::DaliException e) {
85923       {
85924         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85925       };
85926     } catch (...) {
85927       {
85928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85929       };
85930     }
85931   }
85932
85933   jresult = (void *)result;
85934   return jresult;
85935 }
85936
85937
85938 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionBackSignal(void * jarg1) {
85939   void * jresult ;
85940   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85941   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85942
85943   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85944   {
85945     try {
85946       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionBackSignal();
85947     } catch (std::out_of_range& e) {
85948       {
85949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85950       };
85951     } catch (std::exception& e) {
85952       {
85953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85954       };
85955     } catch (Dali::DaliException e) {
85956       {
85957         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85958       };
85959     } catch (...) {
85960       {
85961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85962       };
85963     }
85964   }
85965
85966   jresult = (void *)result;
85967   return jresult;
85968 }
85969
85970
85971 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollUpSignal(void * jarg1) {
85972   void * jresult ;
85973   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85974   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85975
85976   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85977   {
85978     try {
85979       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollUpSignal();
85980     } catch (std::out_of_range& e) {
85981       {
85982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85983       };
85984     } catch (std::exception& e) {
85985       {
85986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85987       };
85988     } catch (Dali::DaliException e) {
85989       {
85990         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85991       };
85992     } catch (...) {
85993       {
85994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85995       };
85996     }
85997   }
85998
85999   jresult = (void *)result;
86000   return jresult;
86001 }
86002
86003
86004 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollDownSignal(void * jarg1) {
86005   void * jresult ;
86006   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86007   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86008
86009   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86010   {
86011     try {
86012       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollDownSignal();
86013     } catch (std::out_of_range& e) {
86014       {
86015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86016       };
86017     } catch (std::exception& e) {
86018       {
86019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86020       };
86021     } catch (Dali::DaliException e) {
86022       {
86023         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86024       };
86025     } catch (...) {
86026       {
86027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86028       };
86029     }
86030   }
86031
86032   jresult = (void *)result;
86033   return jresult;
86034 }
86035
86036
86037 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageLeftSignal(void * jarg1) {
86038   void * jresult ;
86039   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86040   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86041
86042   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86043   {
86044     try {
86045       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageLeftSignal();
86046     } catch (std::out_of_range& e) {
86047       {
86048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86049       };
86050     } catch (std::exception& e) {
86051       {
86052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86053       };
86054     } catch (Dali::DaliException e) {
86055       {
86056         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86057       };
86058     } catch (...) {
86059       {
86060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86061       };
86062     }
86063   }
86064
86065   jresult = (void *)result;
86066   return jresult;
86067 }
86068
86069
86070 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageRightSignal(void * jarg1) {
86071   void * jresult ;
86072   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86073   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86074
86075   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86076   {
86077     try {
86078       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageRightSignal();
86079     } catch (std::out_of_range& e) {
86080       {
86081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86082       };
86083     } catch (std::exception& e) {
86084       {
86085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86086       };
86087     } catch (Dali::DaliException e) {
86088       {
86089         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86090       };
86091     } catch (...) {
86092       {
86093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86094       };
86095     }
86096   }
86097
86098   jresult = (void *)result;
86099   return jresult;
86100 }
86101
86102
86103 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageUpSignal(void * jarg1) {
86104   void * jresult ;
86105   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86106   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86107
86108   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86109   {
86110     try {
86111       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageUpSignal();
86112     } catch (std::out_of_range& e) {
86113       {
86114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86115       };
86116     } catch (std::exception& e) {
86117       {
86118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86119       };
86120     } catch (Dali::DaliException e) {
86121       {
86122         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86123       };
86124     } catch (...) {
86125       {
86126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86127       };
86128     }
86129   }
86130
86131   jresult = (void *)result;
86132   return jresult;
86133 }
86134
86135
86136 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageDownSignal(void * jarg1) {
86137   void * jresult ;
86138   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86139   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86140
86141   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86142   {
86143     try {
86144       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageDownSignal();
86145     } catch (std::out_of_range& e) {
86146       {
86147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86148       };
86149     } catch (std::exception& e) {
86150       {
86151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86152       };
86153     } catch (Dali::DaliException e) {
86154       {
86155         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86156       };
86157     } catch (...) {
86158       {
86159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86160       };
86161     }
86162   }
86163
86164   jresult = (void *)result;
86165   return jresult;
86166 }
86167
86168
86169 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToFirstSignal(void * jarg1) {
86170   void * jresult ;
86171   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86172   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86173
86174   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86175   {
86176     try {
86177       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToFirstSignal();
86178     } catch (std::out_of_range& e) {
86179       {
86180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86181       };
86182     } catch (std::exception& e) {
86183       {
86184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86185       };
86186     } catch (Dali::DaliException e) {
86187       {
86188         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86189       };
86190     } catch (...) {
86191       {
86192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86193       };
86194     }
86195   }
86196
86197   jresult = (void *)result;
86198   return jresult;
86199 }
86200
86201
86202 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToLastSignal(void * jarg1) {
86203   void * jresult ;
86204   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86205   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86206
86207   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86208   {
86209     try {
86210       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToLastSignal();
86211     } catch (std::out_of_range& e) {
86212       {
86213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86214       };
86215     } catch (std::exception& e) {
86216       {
86217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86218       };
86219     } catch (Dali::DaliException e) {
86220       {
86221         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86222       };
86223     } catch (...) {
86224       {
86225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86226       };
86227     }
86228   }
86229
86230   jresult = (void *)result;
86231   return jresult;
86232 }
86233
86234
86235 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromTopSignal(void * jarg1) {
86236   void * jresult ;
86237   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86238   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86239
86240   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86241   {
86242     try {
86243       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromTopSignal();
86244     } catch (std::out_of_range& e) {
86245       {
86246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86247       };
86248     } catch (std::exception& e) {
86249       {
86250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86251       };
86252     } catch (Dali::DaliException e) {
86253       {
86254         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86255       };
86256     } catch (...) {
86257       {
86258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86259       };
86260     }
86261   }
86262
86263   jresult = (void *)result;
86264   return jresult;
86265 }
86266
86267
86268 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromNextSignal(void * jarg1) {
86269   void * jresult ;
86270   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86271   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86272
86273   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86274   {
86275     try {
86276       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromNextSignal();
86277     } catch (std::out_of_range& e) {
86278       {
86279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86280       };
86281     } catch (std::exception& e) {
86282       {
86283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86284       };
86285     } catch (Dali::DaliException e) {
86286       {
86287         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86288       };
86289     } catch (...) {
86290       {
86291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86292       };
86293     }
86294   }
86295
86296   jresult = (void *)result;
86297   return jresult;
86298 }
86299
86300
86301 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionZoomSignal(void * jarg1) {
86302   void * jresult ;
86303   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86304   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86305
86306   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86307   {
86308     try {
86309       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionZoomSignal();
86310     } catch (std::out_of_range& e) {
86311       {
86312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86313       };
86314     } catch (std::exception& e) {
86315       {
86316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86317       };
86318     } catch (Dali::DaliException e) {
86319       {
86320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86321       };
86322     } catch (...) {
86323       {
86324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86325       };
86326     }
86327   }
86328
86329   jresult = (void *)result;
86330   return jresult;
86331 }
86332
86333
86334 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadIndicatorInformationSignal(void * jarg1) {
86335   void * jresult ;
86336   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86337   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86338
86339   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86340   {
86341     try {
86342       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadIndicatorInformationSignal();
86343     } catch (std::out_of_range& e) {
86344       {
86345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86346       };
86347     } catch (std::exception& e) {
86348       {
86349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86350       };
86351     } catch (Dali::DaliException e) {
86352       {
86353         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86354       };
86355     } catch (...) {
86356       {
86357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86358       };
86359     }
86360   }
86361
86362   jresult = (void *)result;
86363   return jresult;
86364 }
86365
86366
86367 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPauseResumeSignal(void * jarg1) {
86368   void * jresult ;
86369   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86370   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86371
86372   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86373   {
86374     try {
86375       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPauseResumeSignal();
86376     } catch (std::out_of_range& e) {
86377       {
86378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86379       };
86380     } catch (std::exception& e) {
86381       {
86382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86383       };
86384     } catch (Dali::DaliException e) {
86385       {
86386         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86387       };
86388     } catch (...) {
86389       {
86390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86391       };
86392     }
86393   }
86394
86395   jresult = (void *)result;
86396   return jresult;
86397 }
86398
86399
86400 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionStartStopSignal(void * jarg1) {
86401   void * jresult ;
86402   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86403   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86404
86405   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86406   {
86407     try {
86408       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionStartStopSignal();
86409     } catch (std::out_of_range& e) {
86410       {
86411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86412       };
86413     } catch (std::exception& e) {
86414       {
86415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86416       };
86417     } catch (Dali::DaliException e) {
86418       {
86419         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86420       };
86421     } catch (...) {
86422       {
86423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86424       };
86425     }
86426   }
86427
86428   jresult = (void *)result;
86429   return jresult;
86430 }
86431
86432
86433 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollSignal(void * jarg1) {
86434   void * jresult ;
86435   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86436   Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *result = 0 ;
86437
86438   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86439   {
86440     try {
86441       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *) &(arg1)->ActionScrollSignal();
86442     } catch (std::out_of_range& e) {
86443       {
86444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86445       };
86446     } catch (std::exception& e) {
86447       {
86448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86449       };
86450     } catch (Dali::DaliException e) {
86451       {
86452         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86453       };
86454     } catch (...) {
86455       {
86456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86457       };
86458     }
86459   }
86460
86461   jresult = (void *)result;
86462   return jresult;
86463 }
86464
86465
86466 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleManager() {
86467   void * jresult ;
86468   Dali::Toolkit::StyleManager *result = 0 ;
86469
86470   {
86471     try {
86472       result = (Dali::Toolkit::StyleManager *)new Dali::Toolkit::StyleManager();
86473     } catch (std::out_of_range& e) {
86474       {
86475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86476       };
86477     } catch (std::exception& e) {
86478       {
86479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86480       };
86481     } catch (Dali::DaliException e) {
86482       {
86483         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86484       };
86485     } catch (...) {
86486       {
86487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86488       };
86489     }
86490   }
86491
86492   jresult = (void *)result;
86493   return jresult;
86494 }
86495
86496
86497 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleManager(void * jarg1) {
86498   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86499
86500   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86501   {
86502     try {
86503       delete arg1;
86504     } catch (std::out_of_range& e) {
86505       {
86506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86507       };
86508     } catch (std::exception& e) {
86509       {
86510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86511       };
86512     } catch (Dali::DaliException e) {
86513       {
86514         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86515       };
86516     } catch (...) {
86517       {
86518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86519       };
86520     }
86521   }
86522
86523 }
86524
86525
86526 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_Get() {
86527   void * jresult ;
86528   Dali::Toolkit::StyleManager result;
86529
86530   {
86531     try {
86532       result = Dali::Toolkit::StyleManager::Get();
86533     } catch (std::out_of_range& e) {
86534       {
86535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86536       };
86537     } catch (std::exception& e) {
86538       {
86539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86540       };
86541     } catch (Dali::DaliException e) {
86542       {
86543         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86544       };
86545     } catch (...) {
86546       {
86547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86548       };
86549     }
86550   }
86551
86552   jresult = new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)result);
86553   return jresult;
86554 }
86555
86556
86557 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyTheme(void * jarg1, char * jarg2) {
86558   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86559   std::string *arg2 = 0 ;
86560
86561   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86562   if (!jarg2) {
86563     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86564     return ;
86565   }
86566   std::string arg2_str(jarg2);
86567   arg2 = &arg2_str;
86568   {
86569     try {
86570       (arg1)->ApplyTheme((std::string const &)*arg2);
86571     } catch (std::out_of_range& e) {
86572       {
86573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86574       };
86575     } catch (std::exception& e) {
86576       {
86577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86578       };
86579     } catch (Dali::DaliException e) {
86580       {
86581         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86582       };
86583     } catch (...) {
86584       {
86585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86586       };
86587     }
86588   }
86589
86590
86591   //argout typemap for const std::string&
86592
86593 }
86594
86595
86596 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyDefaultTheme(void * jarg1) {
86597   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86598
86599   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86600   {
86601     try {
86602       (arg1)->ApplyDefaultTheme();
86603     } catch (std::out_of_range& e) {
86604       {
86605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86606       };
86607     } catch (std::exception& e) {
86608       {
86609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86610       };
86611     } catch (Dali::DaliException e) {
86612       {
86613         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86614       };
86615     } catch (...) {
86616       {
86617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86618       };
86619     }
86620   }
86621
86622 }
86623
86624
86625 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_SetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
86626   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86627   std::string *arg2 = 0 ;
86628   Dali::Property::Value *arg3 = 0 ;
86629
86630   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86631   if (!jarg2) {
86632     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86633     return ;
86634   }
86635   std::string arg2_str(jarg2);
86636   arg2 = &arg2_str;
86637   arg3 = (Dali::Property::Value *)jarg3;
86638   if (!arg3) {
86639     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
86640     return ;
86641   }
86642   {
86643     try {
86644       (arg1)->SetStyleConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
86645     } catch (std::out_of_range& e) {
86646       {
86647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86648       };
86649     } catch (std::exception& e) {
86650       {
86651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86652       };
86653     } catch (Dali::DaliException e) {
86654       {
86655         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86656       };
86657     } catch (...) {
86658       {
86659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86660       };
86661     }
86662   }
86663
86664
86665   //argout typemap for const std::string&
86666
86667 }
86668
86669
86670 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleManager_GetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
86671   unsigned int jresult ;
86672   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86673   std::string *arg2 = 0 ;
86674   Dali::Property::Value *arg3 = 0 ;
86675   bool result;
86676
86677   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86678   if (!jarg2) {
86679     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86680     return 0;
86681   }
86682   std::string arg2_str(jarg2);
86683   arg2 = &arg2_str;
86684   arg3 = (Dali::Property::Value *)jarg3;
86685   if (!arg3) {
86686     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value & type is null", 0);
86687     return 0;
86688   }
86689   {
86690     try {
86691       result = (bool)(arg1)->GetStyleConstant((std::string const &)*arg2,*arg3);
86692     } catch (std::out_of_range& e) {
86693       {
86694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86695       };
86696     } catch (std::exception& e) {
86697       {
86698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86699       };
86700     } catch (Dali::DaliException e) {
86701       {
86702         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86703       };
86704     } catch (...) {
86705       {
86706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86707       };
86708     }
86709   }
86710
86711   jresult = result;
86712
86713   //argout typemap for const std::string&
86714
86715   return jresult;
86716 }
86717
86718
86719 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyStyle(void * jarg1, void * jarg2, char * jarg3, char * jarg4) {
86720   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86721   Dali::Toolkit::Control arg2 ;
86722   std::string *arg3 = 0 ;
86723   std::string *arg4 = 0 ;
86724   Dali::Toolkit::Control *argp2 ;
86725
86726   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86727   argp2 = (Dali::Toolkit::Control *)jarg2;
86728   if (!argp2) {
86729     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
86730     return ;
86731   }
86732   arg2 = *argp2;
86733   if (!jarg3) {
86734     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86735     return ;
86736   }
86737   std::string arg3_str(jarg3);
86738   arg3 = &arg3_str;
86739   if (!jarg4) {
86740     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86741     return ;
86742   }
86743   std::string arg4_str(jarg4);
86744   arg4 = &arg4_str;
86745   {
86746     try {
86747       (arg1)->ApplyStyle(arg2,(std::string const &)*arg3,(std::string const &)*arg4);
86748     } catch (std::out_of_range& e) {
86749       {
86750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86751       };
86752     } catch (std::exception& e) {
86753       {
86754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86755       };
86756     } catch (Dali::DaliException e) {
86757       {
86758         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86759       };
86760     } catch (...) {
86761       {
86762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86763       };
86764     }
86765   }
86766
86767
86768   //argout typemap for const std::string&
86769
86770
86771   //argout typemap for const std::string&
86772
86773 }
86774
86775
86776 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_StyleChangedSignal(void * jarg1) {
86777   void * jresult ;
86778   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86779   Dali::Toolkit::StyleManager::StyleChangedSignalType *result = 0 ;
86780
86781   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86782   {
86783     try {
86784       result = (Dali::Toolkit::StyleManager::StyleChangedSignalType *) &(arg1)->StyleChangedSignal();
86785     } catch (std::out_of_range& e) {
86786       {
86787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86788       };
86789     } catch (std::exception& e) {
86790       {
86791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86792       };
86793     } catch (Dali::DaliException e) {
86794       {
86795         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86796       };
86797     } catch (...) {
86798       {
86799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86800       };
86801     }
86802   }
86803
86804   jresult = (void *)result;
86805   return jresult;
86806 }
86807
86808
86809 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_LOWER_BOUND_get() {
86810   int jresult ;
86811   int result;
86812
86813   result = (int)Dali::Toolkit::Slider::Property::LOWER_BOUND;
86814   jresult = (int)result;
86815   return jresult;
86816 }
86817
86818
86819 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_UPPER_BOUND_get() {
86820   int jresult ;
86821   int result;
86822
86823   result = (int)Dali::Toolkit::Slider::Property::UPPER_BOUND;
86824   jresult = (int)result;
86825   return jresult;
86826 }
86827
86828
86829 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_get() {
86830   int jresult ;
86831   int result;
86832
86833   result = (int)Dali::Toolkit::Slider::Property::VALUE;
86834   jresult = (int)result;
86835   return jresult;
86836 }
86837
86838
86839 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_TRACK_VISUAL_get() {
86840   int jresult ;
86841   int result;
86842
86843   result = (int)Dali::Toolkit::Slider::Property::TRACK_VISUAL;
86844   jresult = (int)result;
86845   return jresult;
86846 }
86847
86848
86849 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_HANDLE_VISUAL_get() {
86850   int jresult ;
86851   int result;
86852
86853   result = (int)Dali::Toolkit::Slider::Property::HANDLE_VISUAL;
86854   jresult = (int)result;
86855   return jresult;
86856 }
86857
86858
86859 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_PROGRESS_VISUAL_get() {
86860   int jresult ;
86861   int result;
86862
86863   result = (int)Dali::Toolkit::Slider::Property::PROGRESS_VISUAL;
86864   jresult = (int)result;
86865   return jresult;
86866 }
86867
86868
86869 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_VISUAL_get() {
86870   int jresult ;
86871   int result;
86872
86873   result = (int)Dali::Toolkit::Slider::Property::POPUP_VISUAL;
86874   jresult = (int)result;
86875   return jresult;
86876 }
86877
86878
86879 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_ARROW_VISUAL_get() {
86880   int jresult ;
86881   int result;
86882
86883   result = (int)Dali::Toolkit::Slider::Property::POPUP_ARROW_VISUAL;
86884   jresult = (int)result;
86885   return jresult;
86886 }
86887
86888
86889 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_DISABLED_COLOR_get() {
86890   int jresult ;
86891   int result;
86892
86893   result = (int)Dali::Toolkit::Slider::Property::DISABLED_COLOR;
86894   jresult = (int)result;
86895   return jresult;
86896 }
86897
86898
86899 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_PRECISION_get() {
86900   int jresult ;
86901   int result;
86902
86903   result = (int)Dali::Toolkit::Slider::Property::VALUE_PRECISION;
86904   jresult = (int)result;
86905   return jresult;
86906 }
86907
86908
86909 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_POPUP_get() {
86910   int jresult ;
86911   int result;
86912
86913   result = (int)Dali::Toolkit::Slider::Property::SHOW_POPUP;
86914   jresult = (int)result;
86915   return jresult;
86916 }
86917
86918
86919 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_VALUE_get() {
86920   int jresult ;
86921   int result;
86922
86923   result = (int)Dali::Toolkit::Slider::Property::SHOW_VALUE;
86924   jresult = (int)result;
86925   return jresult;
86926 }
86927
86928
86929 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARKS_get() {
86930   int jresult ;
86931   int result;
86932
86933   result = (int)Dali::Toolkit::Slider::Property::MARKS;
86934   jresult = (int)result;
86935   return jresult;
86936 }
86937
86938
86939 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SNAP_TO_MARKS_get() {
86940   int jresult ;
86941   int result;
86942
86943   result = (int)Dali::Toolkit::Slider::Property::SNAP_TO_MARKS;
86944   jresult = (int)result;
86945   return jresult;
86946 }
86947
86948
86949 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARK_TOLERANCE_get() {
86950   int jresult ;
86951   int result;
86952
86953   result = (int)Dali::Toolkit::Slider::Property::MARK_TOLERANCE;
86954   jresult = (int)result;
86955   return jresult;
86956 }
86957
86958
86959 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider_Property() {
86960   void * jresult ;
86961   Dali::Toolkit::Slider::Property *result = 0 ;
86962
86963   {
86964     try {
86965       result = (Dali::Toolkit::Slider::Property *)new Dali::Toolkit::Slider::Property();
86966     } catch (std::out_of_range& e) {
86967       {
86968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86969       };
86970     } catch (std::exception& e) {
86971       {
86972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86973       };
86974     } catch (Dali::DaliException e) {
86975       {
86976         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86977       };
86978     } catch (...) {
86979       {
86980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86981       };
86982     }
86983   }
86984
86985   jresult = (void *)result;
86986   return jresult;
86987 }
86988
86989
86990 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider_Property(void * jarg1) {
86991   Dali::Toolkit::Slider::Property *arg1 = (Dali::Toolkit::Slider::Property *) 0 ;
86992
86993   arg1 = (Dali::Toolkit::Slider::Property *)jarg1;
86994   {
86995     try {
86996       delete arg1;
86997     } catch (std::out_of_range& e) {
86998       {
86999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87000       };
87001     } catch (std::exception& e) {
87002       {
87003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87004       };
87005     } catch (Dali::DaliException e) {
87006       {
87007         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87008       };
87009     } catch (...) {
87010       {
87011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87012       };
87013     }
87014   }
87015
87016 }
87017
87018
87019 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_New() {
87020   void * jresult ;
87021   Dali::Toolkit::Slider result;
87022
87023   {
87024     try {
87025       result = Dali::Toolkit::Slider::New();
87026     } catch (std::out_of_range& e) {
87027       {
87028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87029       };
87030     } catch (std::exception& e) {
87031       {
87032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87033       };
87034     } catch (Dali::DaliException e) {
87035       {
87036         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87037       };
87038     } catch (...) {
87039       {
87040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87041       };
87042     }
87043   }
87044
87045   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
87046   return jresult;
87047 }
87048
87049
87050 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_0() {
87051   void * jresult ;
87052   Dali::Toolkit::Slider *result = 0 ;
87053
87054   {
87055     try {
87056       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider();
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_new_Slider__SWIG_1(void * jarg1) {
87082   void * jresult ;
87083   Dali::Toolkit::Slider *arg1 = 0 ;
87084   Dali::Toolkit::Slider *result = 0 ;
87085
87086   arg1 = (Dali::Toolkit::Slider *)jarg1;
87087   if (!arg1) {
87088     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
87089     return 0;
87090   }
87091   {
87092     try {
87093       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider((Dali::Toolkit::Slider const &)*arg1);
87094     } catch (std::out_of_range& e) {
87095       {
87096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87097       };
87098     } catch (std::exception& e) {
87099       {
87100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87101       };
87102     } catch (Dali::DaliException e) {
87103       {
87104         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87105       };
87106     } catch (...) {
87107       {
87108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87109       };
87110     }
87111   }
87112
87113   jresult = (void *)result;
87114   return jresult;
87115 }
87116
87117
87118 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_Assign(void * jarg1, void * jarg2) {
87119   void * jresult ;
87120   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
87121   Dali::Toolkit::Slider *arg2 = 0 ;
87122   Dali::Toolkit::Slider *result = 0 ;
87123
87124   arg1 = (Dali::Toolkit::Slider *)jarg1;
87125   arg2 = (Dali::Toolkit::Slider *)jarg2;
87126   if (!arg2) {
87127     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
87128     return 0;
87129   }
87130   {
87131     try {
87132       result = (Dali::Toolkit::Slider *) &(arg1)->operator =((Dali::Toolkit::Slider const &)*arg2);
87133     } catch (std::out_of_range& e) {
87134       {
87135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87136       };
87137     } catch (std::exception& e) {
87138       {
87139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87140       };
87141     } catch (Dali::DaliException e) {
87142       {
87143         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87144       };
87145     } catch (...) {
87146       {
87147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87148       };
87149     }
87150   }
87151
87152   jresult = (void *)result;
87153   return jresult;
87154 }
87155
87156
87157 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider(void * jarg1) {
87158   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
87159
87160   arg1 = (Dali::Toolkit::Slider *)jarg1;
87161   {
87162     try {
87163       delete arg1;
87164     } catch (std::out_of_range& e) {
87165       {
87166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87167       };
87168     } catch (std::exception& e) {
87169       {
87170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87171       };
87172     } catch (Dali::DaliException e) {
87173       {
87174         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87175       };
87176     } catch (...) {
87177       {
87178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87179       };
87180     }
87181   }
87182
87183 }
87184
87185
87186 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_DownCast(void * jarg1) {
87187   void * jresult ;
87188   Dali::BaseHandle arg1 ;
87189   Dali::BaseHandle *argp1 ;
87190   Dali::Toolkit::Slider result;
87191
87192   argp1 = (Dali::BaseHandle *)jarg1;
87193   if (!argp1) {
87194     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
87195     return 0;
87196   }
87197   arg1 = *argp1;
87198   {
87199     try {
87200       result = Dali::Toolkit::Slider::DownCast(arg1);
87201     } catch (std::out_of_range& e) {
87202       {
87203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87204       };
87205     } catch (std::exception& e) {
87206       {
87207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87208       };
87209     } catch (Dali::DaliException e) {
87210       {
87211         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87212       };
87213     } catch (...) {
87214       {
87215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87216       };
87217     }
87218   }
87219
87220   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
87221   return jresult;
87222 }
87223
87224
87225 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_ValueChangedSignal(void * jarg1) {
87226   void * jresult ;
87227   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
87228   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
87229
87230   arg1 = (Dali::Toolkit::Slider *)jarg1;
87231   {
87232     try {
87233       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
87234     } catch (std::out_of_range& e) {
87235       {
87236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87237       };
87238     } catch (std::exception& e) {
87239       {
87240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87241       };
87242     } catch (Dali::DaliException e) {
87243       {
87244         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87245       };
87246     } catch (...) {
87247       {
87248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87249       };
87250     }
87251   }
87252
87253   jresult = (void *)result;
87254   return jresult;
87255 }
87256
87257
87258 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_SlidingFinishedSignal(void * jarg1) {
87259   void * jresult ;
87260   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
87261   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
87262
87263   arg1 = (Dali::Toolkit::Slider *)jarg1;
87264   {
87265     try {
87266       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->SlidingFinishedSignal();
87267     } catch (std::out_of_range& e) {
87268       {
87269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87270       };
87271     } catch (std::exception& e) {
87272       {
87273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87274       };
87275     } catch (Dali::DaliException e) {
87276       {
87277         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87278       };
87279     } catch (...) {
87280       {
87281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87282       };
87283     }
87284   }
87285
87286   jresult = (void *)result;
87287   return jresult;
87288 }
87289
87290
87291 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_MarkReachedSignal(void * jarg1) {
87292   void * jresult ;
87293   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
87294   Dali::Toolkit::Slider::MarkReachedSignalType *result = 0 ;
87295
87296   arg1 = (Dali::Toolkit::Slider *)jarg1;
87297   {
87298     try {
87299       result = (Dali::Toolkit::Slider::MarkReachedSignalType *) &(arg1)->MarkReachedSignal();
87300     } catch (std::out_of_range& e) {
87301       {
87302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87303       };
87304     } catch (std::exception& e) {
87305       {
87306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87307       };
87308     } catch (Dali::DaliException e) {
87309       {
87310         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87311       };
87312     } catch (...) {
87313       {
87314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87315       };
87316     }
87317   }
87318
87319   jresult = (void *)result;
87320   return jresult;
87321 }
87322
87323
87324 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VIDEO_get() {
87325   int jresult ;
87326   int result;
87327
87328   result = (int)Dali::Toolkit::VideoView::Property::VIDEO;
87329   jresult = (int)result;
87330   return jresult;
87331 }
87332
87333
87334 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_LOOPING_get() {
87335   int jresult ;
87336   int result;
87337
87338   result = (int)Dali::Toolkit::VideoView::Property::LOOPING;
87339   jresult = (int)result;
87340   return jresult;
87341 }
87342
87343
87344 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_MUTED_get() {
87345   int jresult ;
87346   int result;
87347
87348   result = (int)Dali::Toolkit::VideoView::Property::MUTED;
87349   jresult = (int)result;
87350   return jresult;
87351 }
87352
87353
87354 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VOLUME_get() {
87355   int jresult ;
87356   int result;
87357
87358   result = (int)Dali::Toolkit::VideoView::Property::VOLUME;
87359   jresult = (int)result;
87360   return jresult;
87361 }
87362
87363
87364 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_UNDERLAY_get() {
87365   int result;
87366
87367   result = (int)Dali::Toolkit::VideoView::Property::UNDERLAY;
87368
87369   return result;
87370 }
87371
87372
87373 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView_Property() {
87374   void * jresult ;
87375   Dali::Toolkit::VideoView::Property *result = 0 ;
87376
87377   {
87378     try {
87379       result = (Dali::Toolkit::VideoView::Property *)new Dali::Toolkit::VideoView::Property();
87380     } catch (std::out_of_range& e) {
87381       {
87382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87383       };
87384     } catch (std::exception& e) {
87385       {
87386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87387       };
87388     } catch (Dali::DaliException e) {
87389       {
87390         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87391       };
87392     } catch (...) {
87393       {
87394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87395       };
87396     }
87397   }
87398
87399   jresult = (void *)result;
87400   return jresult;
87401 }
87402
87403
87404 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView_Property(void * jarg1) {
87405   Dali::Toolkit::VideoView::Property *arg1 = (Dali::Toolkit::VideoView::Property *) 0 ;
87406
87407   arg1 = (Dali::Toolkit::VideoView::Property *)jarg1;
87408   {
87409     try {
87410       delete arg1;
87411     } catch (std::out_of_range& e) {
87412       {
87413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87414       };
87415     } catch (std::exception& e) {
87416       {
87417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87418       };
87419     } catch (Dali::DaliException e) {
87420       {
87421         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87422       };
87423     } catch (...) {
87424       {
87425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87426       };
87427     }
87428   }
87429
87430 }
87431
87432
87433 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_0() {
87434   void * jresult ;
87435   Dali::Toolkit::VideoView result;
87436
87437   {
87438     try {
87439       result = Dali::Toolkit::VideoView::New();
87440     } catch (std::out_of_range& e) {
87441       {
87442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87443       };
87444     } catch (std::exception& e) {
87445       {
87446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87447       };
87448     } catch (Dali::DaliException e) {
87449       {
87450         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87451       };
87452     } catch (...) {
87453       {
87454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87455       };
87456     }
87457   }
87458
87459   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
87460   return jresult;
87461 }
87462
87463
87464 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_1(char * jarg1) {
87465   void * jresult ;
87466   std::string *arg1 = 0 ;
87467   Dali::Toolkit::VideoView result;
87468
87469   if (!jarg1) {
87470     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
87471     return 0;
87472   }
87473   std::string arg1_str(jarg1);
87474   arg1 = &arg1_str;
87475   {
87476     try {
87477       result = Dali::Toolkit::VideoView::New((std::string const &)*arg1);
87478     } catch (std::out_of_range& e) {
87479       {
87480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87481       };
87482     } catch (std::exception& e) {
87483       {
87484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87485       };
87486     } catch (Dali::DaliException e) {
87487       {
87488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87489       };
87490     } catch (...) {
87491       {
87492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87493       };
87494     }
87495   }
87496
87497   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
87498
87499   //argout typemap for const std::string&
87500
87501   return jresult;
87502 }
87503
87504
87505 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_0() {
87506   void * jresult ;
87507   Dali::Toolkit::VideoView *result = 0 ;
87508
87509   {
87510     try {
87511       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView();
87512     } catch (std::out_of_range& e) {
87513       {
87514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87515       };
87516     } catch (std::exception& e) {
87517       {
87518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87519       };
87520     } catch (Dali::DaliException e) {
87521       {
87522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87523       };
87524     } catch (...) {
87525       {
87526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87527       };
87528     }
87529   }
87530
87531   jresult = (void *)result;
87532   return jresult;
87533 }
87534
87535
87536 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView(void * jarg1) {
87537   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87538
87539   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87540   {
87541     try {
87542       delete arg1;
87543     } catch (std::out_of_range& e) {
87544       {
87545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87546       };
87547     } catch (std::exception& e) {
87548       {
87549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87550       };
87551     } catch (Dali::DaliException e) {
87552       {
87553         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87554       };
87555     } catch (...) {
87556       {
87557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87558       };
87559     }
87560   }
87561
87562 }
87563
87564
87565 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_1(void * jarg1) {
87566   void * jresult ;
87567   Dali::Toolkit::VideoView *arg1 = 0 ;
87568   Dali::Toolkit::VideoView *result = 0 ;
87569
87570   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87571   if (!arg1) {
87572     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
87573     return 0;
87574   }
87575   {
87576     try {
87577       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView((Dali::Toolkit::VideoView const &)*arg1);
87578     } catch (std::out_of_range& e) {
87579       {
87580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87581       };
87582     } catch (std::exception& e) {
87583       {
87584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87585       };
87586     } catch (Dali::DaliException e) {
87587       {
87588         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87589       };
87590     } catch (...) {
87591       {
87592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87593       };
87594     }
87595   }
87596
87597   jresult = (void *)result;
87598   return jresult;
87599 }
87600
87601
87602 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_Assign(void * jarg1, void * jarg2) {
87603   void * jresult ;
87604   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87605   Dali::Toolkit::VideoView *arg2 = 0 ;
87606   Dali::Toolkit::VideoView *result = 0 ;
87607
87608   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87609   arg2 = (Dali::Toolkit::VideoView *)jarg2;
87610   if (!arg2) {
87611     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
87612     return 0;
87613   }
87614   {
87615     try {
87616       result = (Dali::Toolkit::VideoView *) &(arg1)->operator =((Dali::Toolkit::VideoView const &)*arg2);
87617     } catch (std::out_of_range& e) {
87618       {
87619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87620       };
87621     } catch (std::exception& e) {
87622       {
87623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87624       };
87625     } catch (Dali::DaliException e) {
87626       {
87627         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87628       };
87629     } catch (...) {
87630       {
87631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87632       };
87633     }
87634   }
87635
87636   jresult = (void *)result;
87637   return jresult;
87638 }
87639
87640
87641 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_DownCast(void * jarg1) {
87642   void * jresult ;
87643   Dali::BaseHandle arg1 ;
87644   Dali::BaseHandle *argp1 ;
87645   Dali::Toolkit::VideoView result;
87646
87647   argp1 = (Dali::BaseHandle *)jarg1;
87648   if (!argp1) {
87649     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
87650     return 0;
87651   }
87652   arg1 = *argp1;
87653   {
87654     try {
87655       result = Dali::Toolkit::VideoView::DownCast(arg1);
87656     } catch (std::out_of_range& e) {
87657       {
87658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87659       };
87660     } catch (std::exception& e) {
87661       {
87662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87663       };
87664     } catch (Dali::DaliException e) {
87665       {
87666         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87667       };
87668     } catch (...) {
87669       {
87670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87671       };
87672     }
87673   }
87674
87675   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
87676   return jresult;
87677 }
87678
87679
87680 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Play(void * jarg1) {
87681   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87682
87683   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87684   {
87685     try {
87686       (arg1)->Play();
87687     } catch (std::out_of_range& e) {
87688       {
87689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87690       };
87691     } catch (std::exception& e) {
87692       {
87693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87694       };
87695     } catch (Dali::DaliException e) {
87696       {
87697         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87698       };
87699     } catch (...) {
87700       {
87701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87702       };
87703     }
87704   }
87705
87706 }
87707
87708
87709 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Pause(void * jarg1) {
87710   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87711
87712   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87713   {
87714     try {
87715       (arg1)->Pause();
87716     } catch (std::out_of_range& e) {
87717       {
87718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87719       };
87720     } catch (std::exception& e) {
87721       {
87722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87723       };
87724     } catch (Dali::DaliException e) {
87725       {
87726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87727       };
87728     } catch (...) {
87729       {
87730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87731       };
87732     }
87733   }
87734
87735 }
87736
87737
87738 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Stop(void * jarg1) {
87739   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87740
87741   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87742   {
87743     try {
87744       (arg1)->Stop();
87745     } catch (std::out_of_range& e) {
87746       {
87747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87748       };
87749     } catch (std::exception& e) {
87750       {
87751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87752       };
87753     } catch (Dali::DaliException e) {
87754       {
87755         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87756       };
87757     } catch (...) {
87758       {
87759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87760       };
87761     }
87762   }
87763
87764 }
87765
87766
87767 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Forward(void * jarg1, int jarg2) {
87768   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87769   int arg2 ;
87770
87771   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87772   arg2 = (int)jarg2;
87773   {
87774     try {
87775       (arg1)->Forward(arg2);
87776     } catch (std::out_of_range& e) {
87777       {
87778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87779       };
87780     } catch (std::exception& e) {
87781       {
87782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87783       };
87784     } catch (Dali::DaliException e) {
87785       {
87786         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87787       };
87788     } catch (...) {
87789       {
87790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87791       };
87792     }
87793   }
87794
87795 }
87796
87797
87798 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Backward(void * jarg1, int jarg2) {
87799   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87800   int arg2 ;
87801
87802   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87803   arg2 = (int)jarg2;
87804   {
87805     try {
87806       (arg1)->Backward(arg2);
87807     } catch (std::out_of_range& e) {
87808       {
87809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87810       };
87811     } catch (std::exception& e) {
87812       {
87813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87814       };
87815     } catch (Dali::DaliException e) {
87816       {
87817         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87818       };
87819     } catch (...) {
87820       {
87821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87822       };
87823     }
87824   }
87825
87826 }
87827
87828
87829 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_FinishedSignal(void * jarg1) {
87830   void * jresult ;
87831   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87832   Dali::Toolkit::VideoView::VideoViewSignalType *result = 0 ;
87833
87834   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87835   {
87836     try {
87837       result = (Dali::Toolkit::VideoView::VideoViewSignalType *) &(arg1)->FinishedSignal();
87838     } catch (std::out_of_range& e) {
87839       {
87840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87841       };
87842     } catch (std::exception& e) {
87843       {
87844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87845       };
87846     } catch (Dali::DaliException e) {
87847       {
87848         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87849       };
87850     } catch (...) {
87851       {
87852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87853       };
87854     }
87855   }
87856
87857   jresult = (void *)result;
87858   return jresult;
87859 }
87860
87861
87862 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TITLE_get() {
87863   int jresult ;
87864   int result;
87865
87866   result = (int)Dali::Toolkit::Popup::Property::TITLE;
87867   jresult = (int)result;
87868   return jresult;
87869 }
87870
87871
87872 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTENT_get() {
87873   int jresult ;
87874   int result;
87875
87876   result = (int)Dali::Toolkit::Popup::Property::CONTENT;
87877   jresult = (int)result;
87878   return jresult;
87879 }
87880
87881
87882 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_FOOTER_get() {
87883   int jresult ;
87884   int result;
87885
87886   result = (int)Dali::Toolkit::Popup::Property::FOOTER;
87887   jresult = (int)result;
87888   return jresult;
87889 }
87890
87891
87892 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_DISPLAY_STATE_get() {
87893   int jresult ;
87894   int result;
87895
87896   result = (int)Dali::Toolkit::Popup::Property::DISPLAY_STATE;
87897   jresult = (int)result;
87898   return jresult;
87899 }
87900
87901
87902 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TOUCH_TRANSPARENT_get() {
87903   int jresult ;
87904   int result;
87905
87906   result = (int)Dali::Toolkit::Popup::Property::TOUCH_TRANSPARENT;
87907   jresult = (int)result;
87908   return jresult;
87909 }
87910
87911
87912 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_VISIBILITY_get() {
87913   int jresult ;
87914   int result;
87915
87916   result = (int)Dali::Toolkit::Popup::Property::TAIL_VISIBILITY;
87917   jresult = (int)result;
87918   return jresult;
87919 }
87920
87921
87922 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_POSITION_get() {
87923   int jresult ;
87924   int result;
87925
87926   result = (int)Dali::Toolkit::Popup::Property::TAIL_POSITION;
87927   jresult = (int)result;
87928   return jresult;
87929 }
87930
87931
87932 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTEXTUAL_MODE_get() {
87933   int jresult ;
87934   int result;
87935
87936   result = (int)Dali::Toolkit::Popup::Property::CONTEXTUAL_MODE;
87937   jresult = (int)result;
87938   return jresult;
87939 }
87940
87941
87942 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_DURATION_get() {
87943   int jresult ;
87944   int result;
87945
87946   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_DURATION;
87947   jresult = (int)result;
87948   return jresult;
87949 }
87950
87951
87952 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_MODE_get() {
87953   int jresult ;
87954   int result;
87955
87956   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_MODE;
87957   jresult = (int)result;
87958   return jresult;
87959 }
87960
87961
87962 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ENTRY_ANIMATION_get() {
87963   int jresult ;
87964   int result;
87965
87966   result = (int)Dali::Toolkit::Popup::Property::ENTRY_ANIMATION;
87967   jresult = (int)result;
87968   return jresult;
87969 }
87970
87971
87972 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_EXIT_ANIMATION_get() {
87973   int jresult ;
87974   int result;
87975
87976   result = (int)Dali::Toolkit::Popup::Property::EXIT_ANIMATION;
87977   jresult = (int)result;
87978   return jresult;
87979 }
87980
87981
87982 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_AUTO_HIDE_DELAY_get() {
87983   int jresult ;
87984   int result;
87985
87986   result = (int)Dali::Toolkit::Popup::Property::AUTO_HIDE_DELAY;
87987   jresult = (int)result;
87988   return jresult;
87989 }
87990
87991
87992 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_ENABLED_get() {
87993   int jresult ;
87994   int result;
87995
87996   result = (int)Dali::Toolkit::Popup::Property::BACKING_ENABLED;
87997   jresult = (int)result;
87998   return jresult;
87999 }
88000
88001
88002 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_COLOR_get() {
88003   int jresult ;
88004   int result;
88005
88006   result = (int)Dali::Toolkit::Popup::Property::BACKING_COLOR;
88007   jresult = (int)result;
88008   return jresult;
88009 }
88010
88011
88012 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_IMAGE_get() {
88013   int jresult ;
88014   int result;
88015
88016   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_IMAGE;
88017   jresult = (int)result;
88018   return jresult;
88019 }
88020
88021
88022 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_BORDER_get() {
88023   int jresult ;
88024   int result;
88025
88026   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_BORDER;
88027   jresult = (int)result;
88028   return jresult;
88029 }
88030
88031
88032 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_UP_IMAGE_get() {
88033   int jresult ;
88034   int result;
88035
88036   result = (int)Dali::Toolkit::Popup::Property::TAIL_UP_IMAGE;
88037   jresult = (int)result;
88038   return jresult;
88039 }
88040
88041
88042 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_DOWN_IMAGE_get() {
88043   int jresult ;
88044   int result;
88045
88046   result = (int)Dali::Toolkit::Popup::Property::TAIL_DOWN_IMAGE;
88047   jresult = (int)result;
88048   return jresult;
88049 }
88050
88051
88052 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_LEFT_IMAGE_get() {
88053   int jresult ;
88054   int result;
88055
88056   result = (int)Dali::Toolkit::Popup::Property::TAIL_LEFT_IMAGE;
88057   jresult = (int)result;
88058   return jresult;
88059 }
88060
88061
88062 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_RIGHT_IMAGE_get() {
88063   int jresult ;
88064   int result;
88065
88066   result = (int)Dali::Toolkit::Popup::Property::TAIL_RIGHT_IMAGE;
88067   jresult = (int)result;
88068   return jresult;
88069 }
88070
88071
88072 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup_Property() {
88073   void * jresult ;
88074   Dali::Toolkit::Popup::Property *result = 0 ;
88075
88076   {
88077     try {
88078       result = (Dali::Toolkit::Popup::Property *)new Dali::Toolkit::Popup::Property();
88079     } catch (std::out_of_range& e) {
88080       {
88081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88082       };
88083     } catch (std::exception& e) {
88084       {
88085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88086       };
88087     } catch (Dali::DaliException e) {
88088       {
88089         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88090       };
88091     } catch (...) {
88092       {
88093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88094       };
88095     }
88096   }
88097
88098   jresult = (void *)result;
88099   return jresult;
88100 }
88101
88102
88103 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup_Property(void * jarg1) {
88104   Dali::Toolkit::Popup::Property *arg1 = (Dali::Toolkit::Popup::Property *) 0 ;
88105
88106   arg1 = (Dali::Toolkit::Popup::Property *)jarg1;
88107   {
88108     try {
88109       delete arg1;
88110     } catch (std::out_of_range& e) {
88111       {
88112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88113       };
88114     } catch (std::exception& e) {
88115       {
88116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88117       };
88118     } catch (Dali::DaliException e) {
88119       {
88120         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88121       };
88122     } catch (...) {
88123       {
88124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88125       };
88126     }
88127   }
88128
88129 }
88130
88131
88132 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_0() {
88133   void * jresult ;
88134   Dali::Toolkit::Popup *result = 0 ;
88135
88136   {
88137     try {
88138       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup();
88139     } catch (std::out_of_range& e) {
88140       {
88141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88142       };
88143     } catch (std::exception& e) {
88144       {
88145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88146       };
88147     } catch (Dali::DaliException e) {
88148       {
88149         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88150       };
88151     } catch (...) {
88152       {
88153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88154       };
88155     }
88156   }
88157
88158   jresult = (void *)result;
88159   return jresult;
88160 }
88161
88162
88163 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_New() {
88164   void * jresult ;
88165   Dali::Toolkit::Popup result;
88166
88167   {
88168     try {
88169       result = Dali::Toolkit::Popup::New();
88170     } catch (std::out_of_range& e) {
88171       {
88172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88173       };
88174     } catch (std::exception& e) {
88175       {
88176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88177       };
88178     } catch (Dali::DaliException e) {
88179       {
88180         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88181       };
88182     } catch (...) {
88183       {
88184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88185       };
88186     }
88187   }
88188
88189   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
88190   return jresult;
88191 }
88192
88193
88194 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup(void * jarg1) {
88195   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88196
88197   arg1 = (Dali::Toolkit::Popup *)jarg1;
88198   {
88199     try {
88200       delete arg1;
88201     } catch (std::out_of_range& e) {
88202       {
88203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88204       };
88205     } catch (std::exception& e) {
88206       {
88207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88208       };
88209     } catch (Dali::DaliException e) {
88210       {
88211         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88212       };
88213     } catch (...) {
88214       {
88215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88216       };
88217     }
88218   }
88219
88220 }
88221
88222
88223 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_1(void * jarg1) {
88224   void * jresult ;
88225   Dali::Toolkit::Popup *arg1 = 0 ;
88226   Dali::Toolkit::Popup *result = 0 ;
88227
88228   arg1 = (Dali::Toolkit::Popup *)jarg1;
88229   if (!arg1) {
88230     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
88231     return 0;
88232   }
88233   {
88234     try {
88235       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup((Dali::Toolkit::Popup const &)*arg1);
88236     } catch (std::out_of_range& e) {
88237       {
88238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88239       };
88240     } catch (std::exception& e) {
88241       {
88242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88243       };
88244     } catch (Dali::DaliException e) {
88245       {
88246         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88247       };
88248     } catch (...) {
88249       {
88250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88251       };
88252     }
88253   }
88254
88255   jresult = (void *)result;
88256   return jresult;
88257 }
88258
88259
88260 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_Assign(void * jarg1, void * jarg2) {
88261   void * jresult ;
88262   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88263   Dali::Toolkit::Popup *arg2 = 0 ;
88264   Dali::Toolkit::Popup *result = 0 ;
88265
88266   arg1 = (Dali::Toolkit::Popup *)jarg1;
88267   arg2 = (Dali::Toolkit::Popup *)jarg2;
88268   if (!arg2) {
88269     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
88270     return 0;
88271   }
88272   {
88273     try {
88274       result = (Dali::Toolkit::Popup *) &(arg1)->operator =((Dali::Toolkit::Popup const &)*arg2);
88275     } catch (std::out_of_range& e) {
88276       {
88277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88278       };
88279     } catch (std::exception& e) {
88280       {
88281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88282       };
88283     } catch (Dali::DaliException e) {
88284       {
88285         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88286       };
88287     } catch (...) {
88288       {
88289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88290       };
88291     }
88292   }
88293
88294   jresult = (void *)result;
88295   return jresult;
88296 }
88297
88298
88299 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_DownCast(void * jarg1) {
88300   void * jresult ;
88301   Dali::BaseHandle arg1 ;
88302   Dali::BaseHandle *argp1 ;
88303   Dali::Toolkit::Popup result;
88304
88305   argp1 = (Dali::BaseHandle *)jarg1;
88306   if (!argp1) {
88307     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
88308     return 0;
88309   }
88310   arg1 = *argp1;
88311   {
88312     try {
88313       result = Dali::Toolkit::Popup::DownCast(arg1);
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::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
88334   return jresult;
88335 }
88336
88337
88338 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetTitle(void * jarg1, void * jarg2) {
88339   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88340   Dali::Actor arg2 ;
88341   Dali::Actor *argp2 ;
88342
88343   arg1 = (Dali::Toolkit::Popup *)jarg1;
88344   argp2 = (Dali::Actor *)jarg2;
88345   if (!argp2) {
88346     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88347     return ;
88348   }
88349   arg2 = *argp2;
88350   {
88351     try {
88352       (arg1)->SetTitle(arg2);
88353     } catch (std::out_of_range& e) {
88354       {
88355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88356       };
88357     } catch (std::exception& e) {
88358       {
88359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88360       };
88361     } catch (Dali::DaliException e) {
88362       {
88363         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88364       };
88365     } catch (...) {
88366       {
88367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88368       };
88369     }
88370   }
88371
88372 }
88373
88374
88375 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetTitle(void * jarg1) {
88376   void * jresult ;
88377   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88378   Dali::Actor result;
88379
88380   arg1 = (Dali::Toolkit::Popup *)jarg1;
88381   {
88382     try {
88383       result = ((Dali::Toolkit::Popup const *)arg1)->GetTitle();
88384     } catch (std::out_of_range& e) {
88385       {
88386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88387       };
88388     } catch (std::exception& e) {
88389       {
88390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88391       };
88392     } catch (Dali::DaliException e) {
88393       {
88394         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88395       };
88396     } catch (...) {
88397       {
88398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88399       };
88400     }
88401   }
88402
88403   jresult = new Dali::Actor((const Dali::Actor &)result);
88404   return jresult;
88405 }
88406
88407
88408 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetContent(void * jarg1, void * jarg2) {
88409   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88410   Dali::Actor arg2 ;
88411   Dali::Actor *argp2 ;
88412
88413   arg1 = (Dali::Toolkit::Popup *)jarg1;
88414   argp2 = (Dali::Actor *)jarg2;
88415   if (!argp2) {
88416     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88417     return ;
88418   }
88419   arg2 = *argp2;
88420   {
88421     try {
88422       (arg1)->SetContent(arg2);
88423     } catch (std::out_of_range& e) {
88424       {
88425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88426       };
88427     } catch (std::exception& e) {
88428       {
88429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88430       };
88431     } catch (Dali::DaliException e) {
88432       {
88433         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88434       };
88435     } catch (...) {
88436       {
88437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88438       };
88439     }
88440   }
88441
88442 }
88443
88444
88445 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetContent(void * jarg1) {
88446   void * jresult ;
88447   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88448   Dali::Actor result;
88449
88450   arg1 = (Dali::Toolkit::Popup *)jarg1;
88451   {
88452     try {
88453       result = ((Dali::Toolkit::Popup const *)arg1)->GetContent();
88454     } catch (std::out_of_range& e) {
88455       {
88456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88457       };
88458     } catch (std::exception& e) {
88459       {
88460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88461       };
88462     } catch (Dali::DaliException e) {
88463       {
88464         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88465       };
88466     } catch (...) {
88467       {
88468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88469       };
88470     }
88471   }
88472
88473   jresult = new Dali::Actor((const Dali::Actor &)result);
88474   return jresult;
88475 }
88476
88477
88478 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetFooter(void * jarg1, void * jarg2) {
88479   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88480   Dali::Actor arg2 ;
88481   Dali::Actor *argp2 ;
88482
88483   arg1 = (Dali::Toolkit::Popup *)jarg1;
88484   argp2 = (Dali::Actor *)jarg2;
88485   if (!argp2) {
88486     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88487     return ;
88488   }
88489   arg2 = *argp2;
88490   {
88491     try {
88492       (arg1)->SetFooter(arg2);
88493     } catch (std::out_of_range& e) {
88494       {
88495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88496       };
88497     } catch (std::exception& e) {
88498       {
88499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88500       };
88501     } catch (Dali::DaliException e) {
88502       {
88503         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88504       };
88505     } catch (...) {
88506       {
88507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88508       };
88509     }
88510   }
88511
88512 }
88513
88514
88515 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetFooter(void * jarg1) {
88516   void * jresult ;
88517   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88518   Dali::Actor result;
88519
88520   arg1 = (Dali::Toolkit::Popup *)jarg1;
88521   {
88522     try {
88523       result = ((Dali::Toolkit::Popup const *)arg1)->GetFooter();
88524     } catch (std::out_of_range& e) {
88525       {
88526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88527       };
88528     } catch (std::exception& e) {
88529       {
88530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88531       };
88532     } catch (Dali::DaliException e) {
88533       {
88534         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88535       };
88536     } catch (...) {
88537       {
88538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88539       };
88540     }
88541   }
88542
88543   jresult = new Dali::Actor((const Dali::Actor &)result);
88544   return jresult;
88545 }
88546
88547
88548 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetDisplayState(void * jarg1, int jarg2) {
88549   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88550   Dali::Toolkit::Popup::DisplayState arg2 ;
88551
88552   arg1 = (Dali::Toolkit::Popup *)jarg1;
88553   arg2 = (Dali::Toolkit::Popup::DisplayState)jarg2;
88554   {
88555     try {
88556       (arg1)->SetDisplayState(arg2);
88557     } catch (std::out_of_range& e) {
88558       {
88559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88560       };
88561     } catch (std::exception& e) {
88562       {
88563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88564       };
88565     } catch (Dali::DaliException e) {
88566       {
88567         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88568       };
88569     } catch (...) {
88570       {
88571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88572       };
88573     }
88574   }
88575
88576 }
88577
88578
88579 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_GetDisplayState(void * jarg1) {
88580   int jresult ;
88581   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88582   Dali::Toolkit::Popup::DisplayState result;
88583
88584   arg1 = (Dali::Toolkit::Popup *)jarg1;
88585   {
88586     try {
88587       result = (Dali::Toolkit::Popup::DisplayState)((Dali::Toolkit::Popup const *)arg1)->GetDisplayState();
88588     } catch (std::out_of_range& e) {
88589       {
88590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88591       };
88592     } catch (std::exception& e) {
88593       {
88594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88595       };
88596     } catch (Dali::DaliException e) {
88597       {
88598         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88599       };
88600     } catch (...) {
88601       {
88602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88603       };
88604     }
88605   }
88606
88607   jresult = (int)result;
88608   return jresult;
88609 }
88610
88611
88612 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_OutsideTouchedSignal(void * jarg1) {
88613   void * jresult ;
88614   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88615   Dali::Toolkit::Popup::TouchedOutsideSignalType *result = 0 ;
88616
88617   arg1 = (Dali::Toolkit::Popup *)jarg1;
88618   {
88619     try {
88620       result = (Dali::Toolkit::Popup::TouchedOutsideSignalType *) &(arg1)->OutsideTouchedSignal();
88621     } catch (std::out_of_range& e) {
88622       {
88623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88624       };
88625     } catch (std::exception& e) {
88626       {
88627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88628       };
88629     } catch (Dali::DaliException e) {
88630       {
88631         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88632       };
88633     } catch (...) {
88634       {
88635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88636       };
88637     }
88638   }
88639
88640   jresult = (void *)result;
88641   return jresult;
88642 }
88643
88644
88645 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShowingSignal(void * jarg1) {
88646   void * jresult ;
88647   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88648   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
88649
88650   arg1 = (Dali::Toolkit::Popup *)jarg1;
88651   {
88652     try {
88653       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShowingSignal();
88654     } catch (std::out_of_range& e) {
88655       {
88656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88657       };
88658     } catch (std::exception& e) {
88659       {
88660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88661       };
88662     } catch (Dali::DaliException e) {
88663       {
88664         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88665       };
88666     } catch (...) {
88667       {
88668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88669       };
88670     }
88671   }
88672
88673   jresult = (void *)result;
88674   return jresult;
88675 }
88676
88677
88678 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShownSignal(void * jarg1) {
88679   void * jresult ;
88680   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88681   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
88682
88683   arg1 = (Dali::Toolkit::Popup *)jarg1;
88684   {
88685     try {
88686       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShownSignal();
88687     } catch (std::out_of_range& e) {
88688       {
88689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88690       };
88691     } catch (std::exception& e) {
88692       {
88693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88694       };
88695     } catch (Dali::DaliException e) {
88696       {
88697         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88698       };
88699     } catch (...) {
88700       {
88701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88702       };
88703     }
88704   }
88705
88706   jresult = (void *)result;
88707   return jresult;
88708 }
88709
88710
88711 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HidingSignal(void * jarg1) {
88712   void * jresult ;
88713   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88714   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
88715
88716   arg1 = (Dali::Toolkit::Popup *)jarg1;
88717   {
88718     try {
88719       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HidingSignal();
88720     } catch (std::out_of_range& e) {
88721       {
88722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88723       };
88724     } catch (std::exception& e) {
88725       {
88726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88727       };
88728     } catch (Dali::DaliException e) {
88729       {
88730         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88731       };
88732     } catch (...) {
88733       {
88734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88735       };
88736     }
88737   }
88738
88739   jresult = (void *)result;
88740   return jresult;
88741 }
88742
88743
88744 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HiddenSignal(void * jarg1) {
88745   void * jresult ;
88746   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88747   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
88748
88749   arg1 = (Dali::Toolkit::Popup *)jarg1;
88750   {
88751     try {
88752       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HiddenSignal();
88753     } catch (std::out_of_range& e) {
88754       {
88755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88756       };
88757     } catch (std::exception& e) {
88758       {
88759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88760       };
88761     } catch (Dali::DaliException e) {
88762       {
88763         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88764       };
88765     } catch (...) {
88766       {
88767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88768       };
88769     }
88770   }
88771
88772   jresult = (void *)result;
88773   return jresult;
88774 }
88775
88776
88777 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VALUE_get() {
88778   int jresult ;
88779   int result;
88780
88781   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VALUE;
88782   jresult = (int)result;
88783   return jresult;
88784 }
88785
88786
88787 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VALUE_get() {
88788   int jresult ;
88789   int result;
88790
88791   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VALUE;
88792   jresult = (int)result;
88793   return jresult;
88794 }
88795
88796
88797 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_get() {
88798   int jresult ;
88799   int result;
88800
88801   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE;
88802   jresult = (int)result;
88803   return jresult;
88804 }
88805
88806
88807 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_TRACK_VISUAL_get() {
88808   int jresult ;
88809   int result;
88810
88811   result = (int)Dali::Toolkit::ProgressBar::Property::TRACK_VISUAL;
88812   jresult = (int)result;
88813   return jresult;
88814 }
88815
88816
88817 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VISUAL_get() {
88818   int jresult ;
88819   int result;
88820
88821   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VISUAL;
88822   jresult = (int)result;
88823   return jresult;
88824 }
88825
88826
88827 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VISUAL_get() {
88828   int jresult ;
88829   int result;
88830
88831   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VISUAL;
88832   jresult = (int)result;
88833   return jresult;
88834 }
88835
88836
88837 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_get() {
88838   int jresult ;
88839   int result;
88840
88841   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL;
88842   jresult = (int)result;
88843   return jresult;
88844 }
88845
88846
88847 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_ANIMATION_get() {
88848   int jresult ;
88849   int result;
88850
88851   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL_ANIMATION;
88852   jresult = (int)result;
88853   return jresult;
88854 }
88855
88856
88857 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_LABEL_VISUAL_get() {
88858   int jresult ;
88859   int result;
88860
88861   result = (int)Dali::Toolkit::ProgressBar::Property::LABEL_VISUAL;
88862   jresult = (int)result;
88863   return jresult;
88864 }
88865
88866
88867 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar_Property() {
88868   void * jresult ;
88869   Dali::Toolkit::ProgressBar::Property *result = 0 ;
88870
88871   {
88872     try {
88873       result = (Dali::Toolkit::ProgressBar::Property *)new Dali::Toolkit::ProgressBar::Property();
88874     } catch (std::out_of_range& e) {
88875       {
88876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88877       };
88878     } catch (std::exception& e) {
88879       {
88880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88881       };
88882     } catch (Dali::DaliException e) {
88883       {
88884         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88885       };
88886     } catch (...) {
88887       {
88888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88889       };
88890     }
88891   }
88892
88893   jresult = (void *)result;
88894   return jresult;
88895 }
88896
88897
88898 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar_Property(void * jarg1) {
88899   Dali::Toolkit::ProgressBar::Property *arg1 = (Dali::Toolkit::ProgressBar::Property *) 0 ;
88900
88901   arg1 = (Dali::Toolkit::ProgressBar::Property *)jarg1;
88902   {
88903     try {
88904       delete arg1;
88905     } catch (std::out_of_range& e) {
88906       {
88907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88908       };
88909     } catch (std::exception& e) {
88910       {
88911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88912       };
88913     } catch (Dali::DaliException e) {
88914       {
88915         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88916       };
88917     } catch (...) {
88918       {
88919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88920       };
88921     }
88922   }
88923
88924 }
88925
88926
88927 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_New() {
88928   void * jresult ;
88929   Dali::Toolkit::ProgressBar result;
88930
88931   {
88932     try {
88933       result = Dali::Toolkit::ProgressBar::New();
88934     } catch (std::out_of_range& e) {
88935       {
88936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88937       };
88938     } catch (std::exception& e) {
88939       {
88940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88941       };
88942     } catch (Dali::DaliException e) {
88943       {
88944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88945       };
88946     } catch (...) {
88947       {
88948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88949       };
88950     }
88951   }
88952
88953   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
88954   return jresult;
88955 }
88956
88957
88958 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_0() {
88959   void * jresult ;
88960   Dali::Toolkit::ProgressBar *result = 0 ;
88961
88962   {
88963     try {
88964       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar();
88965     } catch (std::out_of_range& e) {
88966       {
88967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88968       };
88969     } catch (std::exception& e) {
88970       {
88971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88972       };
88973     } catch (Dali::DaliException e) {
88974       {
88975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88976       };
88977     } catch (...) {
88978       {
88979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88980       };
88981     }
88982   }
88983
88984   jresult = (void *)result;
88985   return jresult;
88986 }
88987
88988
88989 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_1(void * jarg1) {
88990   void * jresult ;
88991   Dali::Toolkit::ProgressBar *arg1 = 0 ;
88992   Dali::Toolkit::ProgressBar *result = 0 ;
88993
88994   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
88995   if (!arg1) {
88996     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
88997     return 0;
88998   }
88999   {
89000     try {
89001       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar((Dali::Toolkit::ProgressBar const &)*arg1);
89002     } catch (std::out_of_range& e) {
89003       {
89004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89005       };
89006     } catch (std::exception& e) {
89007       {
89008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89009       };
89010     } catch (Dali::DaliException e) {
89011       {
89012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89013       };
89014     } catch (...) {
89015       {
89016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89017       };
89018     }
89019   }
89020
89021   jresult = (void *)result;
89022   return jresult;
89023 }
89024
89025
89026 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_Assign(void * jarg1, void * jarg2) {
89027   void * jresult ;
89028   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
89029   Dali::Toolkit::ProgressBar *arg2 = 0 ;
89030   Dali::Toolkit::ProgressBar *result = 0 ;
89031
89032   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
89033   arg2 = (Dali::Toolkit::ProgressBar *)jarg2;
89034   if (!arg2) {
89035     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
89036     return 0;
89037   }
89038   {
89039     try {
89040       result = (Dali::Toolkit::ProgressBar *) &(arg1)->operator =((Dali::Toolkit::ProgressBar const &)*arg2);
89041     } catch (std::out_of_range& e) {
89042       {
89043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89044       };
89045     } catch (std::exception& e) {
89046       {
89047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89048       };
89049     } catch (Dali::DaliException e) {
89050       {
89051         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89052       };
89053     } catch (...) {
89054       {
89055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89056       };
89057     }
89058   }
89059
89060   jresult = (void *)result;
89061   return jresult;
89062 }
89063
89064
89065 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar(void * jarg1) {
89066   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
89067
89068   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
89069   {
89070     try {
89071       delete arg1;
89072     } catch (std::out_of_range& e) {
89073       {
89074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89075       };
89076     } catch (std::exception& e) {
89077       {
89078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89079       };
89080     } catch (Dali::DaliException e) {
89081       {
89082         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89083       };
89084     } catch (...) {
89085       {
89086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89087       };
89088     }
89089   }
89090
89091 }
89092
89093
89094 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_DownCast(void * jarg1) {
89095   void * jresult ;
89096   Dali::BaseHandle arg1 ;
89097   Dali::BaseHandle *argp1 ;
89098   Dali::Toolkit::ProgressBar result;
89099
89100   argp1 = (Dali::BaseHandle *)jarg1;
89101   if (!argp1) {
89102     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
89103     return 0;
89104   }
89105   arg1 = *argp1;
89106   {
89107     try {
89108       result = Dali::Toolkit::ProgressBar::DownCast(arg1);
89109     } catch (std::out_of_range& e) {
89110       {
89111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89112       };
89113     } catch (std::exception& e) {
89114       {
89115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89116       };
89117     } catch (Dali::DaliException e) {
89118       {
89119         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89120       };
89121     } catch (...) {
89122       {
89123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89124       };
89125     }
89126   }
89127
89128   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
89129   return jresult;
89130 }
89131
89132
89133 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_ValueChangedSignal(void * jarg1) {
89134   void * jresult ;
89135   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
89136   Dali::Toolkit::ProgressBar::ValueChangedSignalType *result = 0 ;
89137
89138   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
89139   {
89140     try {
89141       result = (Dali::Toolkit::ProgressBar::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
89142     } catch (std::out_of_range& e) {
89143       {
89144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89145       };
89146     } catch (std::exception& e) {
89147       {
89148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89149       };
89150     } catch (Dali::DaliException e) {
89151       {
89152         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89153       };
89154     } catch (...) {
89155       {
89156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89157       };
89158     }
89159   }
89160
89161   jresult = (void *)result;
89162   return jresult;
89163 }
89164
89165
89166 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_0() {
89167   void * jresult ;
89168   Dali::Toolkit::GaussianBlurView *result = 0 ;
89169
89170   {
89171     try {
89172       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView();
89173     } catch (std::out_of_range& e) {
89174       {
89175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89176       };
89177     } catch (std::exception& e) {
89178       {
89179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89180       };
89181     } catch (Dali::DaliException e) {
89182       {
89183         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89184       };
89185     } catch (...) {
89186       {
89187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89188       };
89189     }
89190   }
89191
89192   jresult = (void *)result;
89193   return jresult;
89194 }
89195
89196
89197 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_1(void * jarg1) {
89198   void * jresult ;
89199   Dali::Toolkit::GaussianBlurView *arg1 = 0 ;
89200   Dali::Toolkit::GaussianBlurView *result = 0 ;
89201
89202   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89203   if (!arg1) {
89204     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
89205     return 0;
89206   }
89207   {
89208     try {
89209       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView((Dali::Toolkit::GaussianBlurView const &)*arg1);
89210     } catch (std::out_of_range& e) {
89211       {
89212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89213       };
89214     } catch (std::exception& e) {
89215       {
89216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89217       };
89218     } catch (Dali::DaliException e) {
89219       {
89220         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89221       };
89222     } catch (...) {
89223       {
89224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89225       };
89226     }
89227   }
89228
89229   jresult = (void *)result;
89230   return jresult;
89231 }
89232
89233
89234 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_Assign(void * jarg1, void * jarg2) {
89235   void * jresult ;
89236   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89237   Dali::Toolkit::GaussianBlurView *arg2 = 0 ;
89238   Dali::Toolkit::GaussianBlurView *result = 0 ;
89239
89240   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89241   arg2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
89242   if (!arg2) {
89243     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
89244     return 0;
89245   }
89246   {
89247     try {
89248       result = (Dali::Toolkit::GaussianBlurView *) &(arg1)->operator =((Dali::Toolkit::GaussianBlurView const &)*arg2);
89249     } catch (std::out_of_range& e) {
89250       {
89251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89252       };
89253     } catch (std::exception& e) {
89254       {
89255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89256       };
89257     } catch (Dali::DaliException e) {
89258       {
89259         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89260       };
89261     } catch (...) {
89262       {
89263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89264       };
89265     }
89266   }
89267
89268   jresult = (void *)result;
89269   return jresult;
89270 }
89271
89272
89273 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurView(void * jarg1) {
89274   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89275
89276   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89277   {
89278     try {
89279       delete arg1;
89280     } catch (std::out_of_range& e) {
89281       {
89282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89283       };
89284     } catch (std::exception& e) {
89285       {
89286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89287       };
89288     } catch (Dali::DaliException e) {
89289       {
89290         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89291       };
89292     } catch (...) {
89293       {
89294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89295       };
89296     }
89297   }
89298
89299 }
89300
89301
89302 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_DownCast(void * jarg1) {
89303   void * jresult ;
89304   Dali::BaseHandle arg1 ;
89305   Dali::BaseHandle *argp1 ;
89306   Dali::Toolkit::GaussianBlurView result;
89307
89308   argp1 = (Dali::BaseHandle *)jarg1;
89309   if (!argp1) {
89310     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
89311     return 0;
89312   }
89313   arg1 = *argp1;
89314   {
89315     try {
89316       result = Dali::Toolkit::GaussianBlurView::DownCast(arg1);
89317     } catch (std::out_of_range& e) {
89318       {
89319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89320       };
89321     } catch (std::exception& e) {
89322       {
89323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89324       };
89325     } catch (Dali::DaliException e) {
89326       {
89327         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89328       };
89329     } catch (...) {
89330       {
89331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89332       };
89333     }
89334   }
89335
89336   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
89337   return jresult;
89338 }
89339
89340
89341 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_0() {
89342   void * jresult ;
89343   Dali::Toolkit::GaussianBlurView result;
89344
89345   {
89346     try {
89347       result = Dali::Toolkit::GaussianBlurView::New();
89348     } catch (std::out_of_range& e) {
89349       {
89350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89351       };
89352     } catch (std::exception& e) {
89353       {
89354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89355       };
89356     } catch (Dali::DaliException e) {
89357       {
89358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89359       };
89360     } catch (...) {
89361       {
89362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89363       };
89364     }
89365   }
89366
89367   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
89368   return jresult;
89369 }
89370
89371
89372 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_1(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5, unsigned int jarg6) {
89373   void * jresult ;
89374   unsigned int arg1 ;
89375   float arg2 ;
89376   Dali::Pixel::Format arg3 ;
89377   float arg4 ;
89378   float arg5 ;
89379   bool arg6 ;
89380   Dali::Toolkit::GaussianBlurView result;
89381
89382   arg1 = (unsigned int)jarg1;
89383   arg2 = (float)jarg2;
89384   arg3 = (Dali::Pixel::Format)jarg3;
89385   arg4 = (float)jarg4;
89386   arg5 = (float)jarg5;
89387   arg6 = jarg6 ? true : false;
89388   {
89389     try {
89390       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5,arg6);
89391     } catch (std::out_of_range& e) {
89392       {
89393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89394       };
89395     } catch (std::exception& e) {
89396       {
89397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89398       };
89399     } catch (Dali::DaliException e) {
89400       {
89401         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89402       };
89403     } catch (...) {
89404       {
89405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89406       };
89407     }
89408   }
89409
89410   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
89411   return jresult;
89412 }
89413
89414
89415 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_2(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5) {
89416   void * jresult ;
89417   unsigned int arg1 ;
89418   float arg2 ;
89419   Dali::Pixel::Format arg3 ;
89420   float arg4 ;
89421   float arg5 ;
89422   Dali::Toolkit::GaussianBlurView result;
89423
89424   arg1 = (unsigned int)jarg1;
89425   arg2 = (float)jarg2;
89426   arg3 = (Dali::Pixel::Format)jarg3;
89427   arg4 = (float)jarg4;
89428   arg5 = (float)jarg5;
89429   {
89430     try {
89431       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5);
89432     } catch (std::out_of_range& e) {
89433       {
89434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89435       };
89436     } catch (std::exception& e) {
89437       {
89438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89439       };
89440     } catch (Dali::DaliException e) {
89441       {
89442         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89443       };
89444     } catch (...) {
89445       {
89446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89447       };
89448     }
89449   }
89450
89451   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
89452   return jresult;
89453 }
89454
89455
89456 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Add(void * jarg1, void * jarg2) {
89457   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89458   Dali::Actor arg2 ;
89459   Dali::Actor *argp2 ;
89460
89461   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89462   argp2 = (Dali::Actor *)jarg2;
89463   if (!argp2) {
89464     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
89465     return ;
89466   }
89467   arg2 = *argp2;
89468   {
89469     try {
89470       (arg1)->Add(arg2);
89471     } catch (std::out_of_range& e) {
89472       {
89473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89474       };
89475     } catch (std::exception& e) {
89476       {
89477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89478       };
89479     } catch (Dali::DaliException e) {
89480       {
89481         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89482       };
89483     } catch (...) {
89484       {
89485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89486       };
89487     }
89488   }
89489
89490 }
89491
89492
89493 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Remove(void * jarg1, void * jarg2) {
89494   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89495   Dali::Actor arg2 ;
89496   Dali::Actor *argp2 ;
89497
89498   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89499   argp2 = (Dali::Actor *)jarg2;
89500   if (!argp2) {
89501     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
89502     return ;
89503   }
89504   arg2 = *argp2;
89505   {
89506     try {
89507       (arg1)->Remove(arg2);
89508     } catch (std::out_of_range& e) {
89509       {
89510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89511       };
89512     } catch (std::exception& e) {
89513       {
89514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89515       };
89516     } catch (Dali::DaliException e) {
89517       {
89518         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89519       };
89520     } catch (...) {
89521       {
89522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89523       };
89524     }
89525   }
89526
89527 }
89528
89529
89530 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Activate(void * jarg1) {
89531   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89532
89533   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89534   {
89535     try {
89536       (arg1)->Activate();
89537     } catch (std::out_of_range& e) {
89538       {
89539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89540       };
89541     } catch (std::exception& e) {
89542       {
89543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89544       };
89545     } catch (Dali::DaliException e) {
89546       {
89547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89548       };
89549     } catch (...) {
89550       {
89551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89552       };
89553     }
89554   }
89555
89556 }
89557
89558
89559 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_ActivateOnce(void * jarg1) {
89560   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89561
89562   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89563   {
89564     try {
89565       (arg1)->ActivateOnce();
89566     } catch (std::out_of_range& e) {
89567       {
89568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89569       };
89570     } catch (std::exception& e) {
89571       {
89572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89573       };
89574     } catch (Dali::DaliException e) {
89575       {
89576         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89577       };
89578     } catch (...) {
89579       {
89580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89581       };
89582     }
89583   }
89584
89585 }
89586
89587
89588 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Deactivate(void * jarg1) {
89589   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89590
89591   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89592   {
89593     try {
89594       (arg1)->Deactivate();
89595     } catch (std::out_of_range& e) {
89596       {
89597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89598       };
89599     } catch (std::exception& e) {
89600       {
89601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89602       };
89603     } catch (Dali::DaliException e) {
89604       {
89605         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89606       };
89607     } catch (...) {
89608       {
89609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89610       };
89611     }
89612   }
89613
89614 }
89615
89616
89617 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetUserImageAndOutputRenderTarget(void * jarg1, void * jarg2, void * jarg3) {
89618   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89619   Dali::Image arg2 ;
89620   Dali::FrameBufferImage arg3 ;
89621   Dali::Image *argp2 ;
89622   Dali::FrameBufferImage *argp3 ;
89623
89624   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89625   argp2 = (Dali::Image *)jarg2;
89626   if (!argp2) {
89627     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
89628     return ;
89629   }
89630   arg2 = *argp2;
89631   argp3 = (Dali::FrameBufferImage *)jarg3;
89632   if (!argp3) {
89633     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBufferImage", 0);
89634     return ;
89635   }
89636   arg3 = *argp3;
89637   {
89638     try {
89639       (arg1)->SetUserImageAndOutputRenderTarget(arg2,arg3);
89640     } catch (std::out_of_range& e) {
89641       {
89642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89643       };
89644     } catch (std::exception& e) {
89645       {
89646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89647       };
89648     } catch (Dali::DaliException e) {
89649       {
89650         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89651       };
89652     } catch (...) {
89653       {
89654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89655       };
89656     }
89657   }
89658
89659 }
89660
89661
89662 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurStrengthPropertyIndex(void * jarg1) {
89663   int jresult ;
89664   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89665   Dali::Property::Index result;
89666
89667   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89668   {
89669     try {
89670       result = (Dali::Property::Index)((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurStrengthPropertyIndex();
89671     } catch (std::out_of_range& e) {
89672       {
89673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89674       };
89675     } catch (std::exception& e) {
89676       {
89677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89678       };
89679     } catch (Dali::DaliException e) {
89680       {
89681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89682       };
89683     } catch (...) {
89684       {
89685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89686       };
89687     }
89688   }
89689
89690   jresult = result;
89691   return jresult;
89692 }
89693
89694
89695 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurredRenderTarget(void * jarg1) {
89696   void * jresult ;
89697   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89698   Dali::FrameBufferImage result;
89699
89700   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89701   {
89702     try {
89703       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurredRenderTarget();
89704     } catch (std::out_of_range& e) {
89705       {
89706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89707       };
89708     } catch (std::exception& e) {
89709       {
89710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89711       };
89712     } catch (Dali::DaliException e) {
89713       {
89714         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89715       };
89716     } catch (...) {
89717       {
89718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89719       };
89720     }
89721   }
89722
89723   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
89724   return jresult;
89725 }
89726
89727
89728 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetBackgroundColor(void * jarg1, void * jarg2) {
89729   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89730   Dali::Vector4 *arg2 = 0 ;
89731
89732   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89733   arg2 = (Dali::Vector4 *)jarg2;
89734   if (!arg2) {
89735     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
89736     return ;
89737   }
89738   {
89739     try {
89740       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
89741     } catch (std::out_of_range& e) {
89742       {
89743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89744       };
89745     } catch (std::exception& e) {
89746       {
89747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89748       };
89749     } catch (Dali::DaliException e) {
89750       {
89751         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89752       };
89753     } catch (...) {
89754       {
89755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89756       };
89757     }
89758   }
89759
89760 }
89761
89762
89763 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBackgroundColor(void * jarg1) {
89764   void * jresult ;
89765   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89766   Dali::Vector4 result;
89767
89768   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89769   {
89770     try {
89771       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBackgroundColor();
89772     } catch (std::out_of_range& e) {
89773       {
89774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89775       };
89776     } catch (std::exception& e) {
89777       {
89778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89779       };
89780     } catch (Dali::DaliException e) {
89781       {
89782         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89783       };
89784     } catch (...) {
89785       {
89786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89787       };
89788     }
89789   }
89790
89791   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
89792   return jresult;
89793 }
89794
89795
89796 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_FinishedSignal(void * jarg1) {
89797   void * jresult ;
89798   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89799   Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *result = 0 ;
89800
89801   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89802   {
89803     try {
89804       result = (Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *) &(arg1)->FinishedSignal();
89805     } catch (std::out_of_range& e) {
89806       {
89807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89808       };
89809     } catch (std::exception& e) {
89810       {
89811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89812       };
89813     } catch (Dali::DaliException e) {
89814       {
89815         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89816       };
89817     } catch (...) {
89818       {
89819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89820       };
89821     }
89822   }
89823
89824   jresult = (void *)result;
89825   return jresult;
89826 }
89827
89828
89829 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageFactory(void * jarg1) {
89830   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
89831
89832   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
89833   {
89834     try {
89835       delete arg1;
89836     } catch (std::out_of_range& e) {
89837       {
89838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89839       };
89840     } catch (std::exception& e) {
89841       {
89842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89843       };
89844     } catch (Dali::DaliException e) {
89845       {
89846         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89847       };
89848     } catch (...) {
89849       {
89850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89851       };
89852     }
89853   }
89854
89855 }
89856
89857
89858 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageFactory_GetNumberOfPages(void * jarg1) {
89859   unsigned int jresult ;
89860   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
89861   unsigned int result;
89862
89863   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
89864   {
89865     try {
89866       result = (unsigned int)(arg1)->GetNumberOfPages();
89867     } catch (std::out_of_range& e) {
89868       {
89869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89870       };
89871     } catch (std::exception& e) {
89872       {
89873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89874       };
89875     } catch (Dali::DaliException e) {
89876       {
89877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89878       };
89879     } catch (...) {
89880       {
89881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89882       };
89883     }
89884   }
89885
89886   jresult = result;
89887   return jresult;
89888 }
89889
89890
89891 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageFactory_NewPage(void * jarg1, unsigned int jarg2) {
89892   void * jresult ;
89893   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
89894   unsigned int arg2 ;
89895   Dali::Texture result;
89896
89897   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
89898   arg2 = (unsigned int)jarg2;
89899   {
89900     try {
89901       result = (arg1)->NewPage(arg2);
89902     } catch (std::out_of_range& e) {
89903       {
89904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89905       };
89906     } catch (std::exception& e) {
89907       {
89908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89909       };
89910     } catch (Dali::DaliException e) {
89911       {
89912         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89913       };
89914     } catch (...) {
89915       {
89916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89917       };
89918     }
89919   }
89920
89921   jresult = new Dali::Texture((const Dali::Texture &)result);
89922   return jresult;
89923 }
89924
89925
89926 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_PAGE_SIZE_get() {
89927   int jresult ;
89928   int result;
89929
89930   result = (int)Dali::Toolkit::PageTurnView::Property::PAGE_SIZE;
89931   jresult = (int)result;
89932   return jresult;
89933 }
89934
89935
89936 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_CURRENT_PAGE_ID_get() {
89937   int jresult ;
89938   int result;
89939
89940   result = (int)Dali::Toolkit::PageTurnView::Property::CURRENT_PAGE_ID;
89941   jresult = (int)result;
89942   return jresult;
89943 }
89944
89945
89946 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_SPINE_SHADOW_get() {
89947   int jresult ;
89948   int result;
89949
89950   result = (int)Dali::Toolkit::PageTurnView::Property::SPINE_SHADOW;
89951   jresult = (int)result;
89952   return jresult;
89953 }
89954
89955
89956 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView_Property() {
89957   void * jresult ;
89958   Dali::Toolkit::PageTurnView::Property *result = 0 ;
89959
89960   {
89961     try {
89962       result = (Dali::Toolkit::PageTurnView::Property *)new Dali::Toolkit::PageTurnView::Property();
89963     } catch (std::out_of_range& e) {
89964       {
89965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89966       };
89967     } catch (std::exception& e) {
89968       {
89969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89970       };
89971     } catch (Dali::DaliException e) {
89972       {
89973         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89974       };
89975     } catch (...) {
89976       {
89977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89978       };
89979     }
89980   }
89981
89982   jresult = (void *)result;
89983   return jresult;
89984 }
89985
89986
89987 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView_Property(void * jarg1) {
89988   Dali::Toolkit::PageTurnView::Property *arg1 = (Dali::Toolkit::PageTurnView::Property *) 0 ;
89989
89990   arg1 = (Dali::Toolkit::PageTurnView::Property *)jarg1;
89991   {
89992     try {
89993       delete arg1;
89994     } catch (std::out_of_range& e) {
89995       {
89996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89997       };
89998     } catch (std::exception& e) {
89999       {
90000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90001       };
90002     } catch (Dali::DaliException e) {
90003       {
90004         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90005       };
90006     } catch (...) {
90007       {
90008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90009       };
90010     }
90011   }
90012
90013 }
90014
90015
90016 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_0() {
90017   void * jresult ;
90018   Dali::Toolkit::PageTurnView *result = 0 ;
90019
90020   {
90021     try {
90022       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView();
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_new_PageTurnView__SWIG_1(void * jarg1) {
90048   void * jresult ;
90049   Dali::Toolkit::PageTurnView *arg1 = 0 ;
90050   Dali::Toolkit::PageTurnView *result = 0 ;
90051
90052   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
90053   if (!arg1) {
90054     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
90055     return 0;
90056   }
90057   {
90058     try {
90059       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView((Dali::Toolkit::PageTurnView const &)*arg1);
90060     } catch (std::out_of_range& e) {
90061       {
90062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90063       };
90064     } catch (std::exception& e) {
90065       {
90066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90067       };
90068     } catch (Dali::DaliException e) {
90069       {
90070         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90071       };
90072     } catch (...) {
90073       {
90074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90075       };
90076     }
90077   }
90078
90079   jresult = (void *)result;
90080   return jresult;
90081 }
90082
90083
90084 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_Assign(void * jarg1, void * jarg2) {
90085   void * jresult ;
90086   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
90087   Dali::Toolkit::PageTurnView *arg2 = 0 ;
90088   Dali::Toolkit::PageTurnView *result = 0 ;
90089
90090   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
90091   arg2 = (Dali::Toolkit::PageTurnView *)jarg2;
90092   if (!arg2) {
90093     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
90094     return 0;
90095   }
90096   {
90097     try {
90098       result = (Dali::Toolkit::PageTurnView *) &(arg1)->operator =((Dali::Toolkit::PageTurnView const &)*arg2);
90099     } catch (std::out_of_range& e) {
90100       {
90101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90102       };
90103     } catch (std::exception& e) {
90104       {
90105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90106       };
90107     } catch (Dali::DaliException e) {
90108       {
90109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90110       };
90111     } catch (...) {
90112       {
90113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90114       };
90115     }
90116   }
90117
90118   jresult = (void *)result;
90119   return jresult;
90120 }
90121
90122
90123 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView(void * jarg1) {
90124   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
90125
90126   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
90127   {
90128     try {
90129       delete arg1;
90130     } catch (std::out_of_range& e) {
90131       {
90132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90133       };
90134     } catch (std::exception& e) {
90135       {
90136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90137       };
90138     } catch (Dali::DaliException e) {
90139       {
90140         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90141       };
90142     } catch (...) {
90143       {
90144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90145       };
90146     }
90147   }
90148
90149 }
90150
90151
90152 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_DownCast(void * jarg1) {
90153   void * jresult ;
90154   Dali::BaseHandle arg1 ;
90155   Dali::BaseHandle *argp1 ;
90156   Dali::Toolkit::PageTurnView result;
90157
90158   argp1 = (Dali::BaseHandle *)jarg1;
90159   if (!argp1) {
90160     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
90161     return 0;
90162   }
90163   arg1 = *argp1;
90164   {
90165     try {
90166       result = Dali::Toolkit::PageTurnView::DownCast(arg1);
90167     } catch (std::out_of_range& e) {
90168       {
90169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90170       };
90171     } catch (std::exception& e) {
90172       {
90173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90174       };
90175     } catch (Dali::DaliException e) {
90176       {
90177         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90178       };
90179     } catch (...) {
90180       {
90181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90182       };
90183     }
90184   }
90185
90186   jresult = new Dali::Toolkit::PageTurnView((const Dali::Toolkit::PageTurnView &)result);
90187   return jresult;
90188 }
90189
90190
90191 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnStartedSignal(void * jarg1) {
90192   void * jresult ;
90193   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
90194   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
90195
90196   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
90197   {
90198     try {
90199       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnStartedSignal();
90200     } catch (std::out_of_range& e) {
90201       {
90202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90203       };
90204     } catch (std::exception& e) {
90205       {
90206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90207       };
90208     } catch (Dali::DaliException e) {
90209       {
90210         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90211       };
90212     } catch (...) {
90213       {
90214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90215       };
90216     }
90217   }
90218
90219   jresult = (void *)result;
90220   return jresult;
90221 }
90222
90223
90224 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnFinishedSignal(void * jarg1) {
90225   void * jresult ;
90226   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
90227   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
90228
90229   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
90230   {
90231     try {
90232       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnFinishedSignal();
90233     } catch (std::out_of_range& e) {
90234       {
90235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90236       };
90237     } catch (std::exception& e) {
90238       {
90239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90240       };
90241     } catch (Dali::DaliException e) {
90242       {
90243         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90244       };
90245     } catch (...) {
90246       {
90247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90248       };
90249     }
90250   }
90251
90252   jresult = (void *)result;
90253   return jresult;
90254 }
90255
90256
90257 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanStartedSignal(void * jarg1) {
90258   void * jresult ;
90259   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
90260   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
90261
90262   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
90263   {
90264     try {
90265       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanStartedSignal();
90266     } catch (std::out_of_range& e) {
90267       {
90268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90269       };
90270     } catch (std::exception& e) {
90271       {
90272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90273       };
90274     } catch (Dali::DaliException e) {
90275       {
90276         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90277       };
90278     } catch (...) {
90279       {
90280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90281       };
90282     }
90283   }
90284
90285   jresult = (void *)result;
90286   return jresult;
90287 }
90288
90289
90290 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanFinishedSignal(void * jarg1) {
90291   void * jresult ;
90292   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
90293   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
90294
90295   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
90296   {
90297     try {
90298       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanFinishedSignal();
90299     } catch (std::out_of_range& e) {
90300       {
90301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90302       };
90303     } catch (std::exception& e) {
90304       {
90305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90306       };
90307     } catch (Dali::DaliException e) {
90308       {
90309         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90310       };
90311     } catch (...) {
90312       {
90313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90314       };
90315     }
90316   }
90317
90318   jresult = (void *)result;
90319   return jresult;
90320 }
90321
90322
90323 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_0() {
90324   void * jresult ;
90325   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
90326
90327   {
90328     try {
90329       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView();
90330     } catch (std::out_of_range& e) {
90331       {
90332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90333       };
90334     } catch (std::exception& e) {
90335       {
90336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90337       };
90338     } catch (Dali::DaliException e) {
90339       {
90340         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90341       };
90342     } catch (...) {
90343       {
90344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90345       };
90346     }
90347   }
90348
90349   jresult = (void *)result;
90350   return jresult;
90351 }
90352
90353
90354 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_1(void * jarg1) {
90355   void * jresult ;
90356   Dali::Toolkit::PageTurnLandscapeView *arg1 = 0 ;
90357   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
90358
90359   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
90360   if (!arg1) {
90361     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
90362     return 0;
90363   }
90364   {
90365     try {
90366       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView((Dali::Toolkit::PageTurnLandscapeView const &)*arg1);
90367     } catch (std::out_of_range& e) {
90368       {
90369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90370       };
90371     } catch (std::exception& e) {
90372       {
90373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90374       };
90375     } catch (Dali::DaliException e) {
90376       {
90377         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90378       };
90379     } catch (...) {
90380       {
90381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90382       };
90383     }
90384   }
90385
90386   jresult = (void *)result;
90387   return jresult;
90388 }
90389
90390
90391 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_Assign(void * jarg1, void * jarg2) {
90392   void * jresult ;
90393   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
90394   Dali::Toolkit::PageTurnLandscapeView *arg2 = 0 ;
90395   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
90396
90397   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
90398   arg2 = (Dali::Toolkit::PageTurnLandscapeView *)jarg2;
90399   if (!arg2) {
90400     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
90401     return 0;
90402   }
90403   {
90404     try {
90405       result = (Dali::Toolkit::PageTurnLandscapeView *) &(arg1)->operator =((Dali::Toolkit::PageTurnLandscapeView const &)*arg2);
90406     } catch (std::out_of_range& e) {
90407       {
90408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90409       };
90410     } catch (std::exception& e) {
90411       {
90412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90413       };
90414     } catch (Dali::DaliException e) {
90415       {
90416         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90417       };
90418     } catch (...) {
90419       {
90420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90421       };
90422     }
90423   }
90424
90425   jresult = (void *)result;
90426   return jresult;
90427 }
90428
90429
90430 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnLandscapeView(void * jarg1) {
90431   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
90432
90433   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
90434   {
90435     try {
90436       delete arg1;
90437     } catch (std::out_of_range& e) {
90438       {
90439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90440       };
90441     } catch (std::exception& e) {
90442       {
90443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90444       };
90445     } catch (Dali::DaliException e) {
90446       {
90447         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90448       };
90449     } catch (...) {
90450       {
90451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90452       };
90453     }
90454   }
90455
90456 }
90457
90458
90459 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_New(void * jarg1, void * jarg2) {
90460   void * jresult ;
90461   Dali::Toolkit::PageFactory *arg1 = 0 ;
90462   Dali::Vector2 *arg2 = 0 ;
90463   Dali::Toolkit::PageTurnLandscapeView result;
90464
90465   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
90466   if (!arg1) {
90467     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
90468     return 0;
90469   }
90470   arg2 = (Dali::Vector2 *)jarg2;
90471   if (!arg2) {
90472     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
90473     return 0;
90474   }
90475   {
90476     try {
90477       result = Dali::Toolkit::PageTurnLandscapeView::New(*arg1,(Dali::Vector2 const &)*arg2);
90478     } catch (std::out_of_range& e) {
90479       {
90480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90481       };
90482     } catch (std::exception& e) {
90483       {
90484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90485       };
90486     } catch (Dali::DaliException e) {
90487       {
90488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90489       };
90490     } catch (...) {
90491       {
90492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90493       };
90494     }
90495   }
90496
90497   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
90498   return jresult;
90499 }
90500
90501
90502 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_DownCast(void * jarg1) {
90503   void * jresult ;
90504   Dali::BaseHandle arg1 ;
90505   Dali::BaseHandle *argp1 ;
90506   Dali::Toolkit::PageTurnLandscapeView result;
90507
90508   argp1 = (Dali::BaseHandle *)jarg1;
90509   if (!argp1) {
90510     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
90511     return 0;
90512   }
90513   arg1 = *argp1;
90514   {
90515     try {
90516       result = Dali::Toolkit::PageTurnLandscapeView::DownCast(arg1);
90517     } catch (std::out_of_range& e) {
90518       {
90519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90520       };
90521     } catch (std::exception& e) {
90522       {
90523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90524       };
90525     } catch (Dali::DaliException e) {
90526       {
90527         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90528       };
90529     } catch (...) {
90530       {
90531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90532       };
90533     }
90534   }
90535
90536   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
90537   return jresult;
90538 }
90539
90540
90541 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_0() {
90542   void * jresult ;
90543   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
90544
90545   {
90546     try {
90547       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView();
90548     } catch (std::out_of_range& e) {
90549       {
90550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90551       };
90552     } catch (std::exception& e) {
90553       {
90554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90555       };
90556     } catch (Dali::DaliException e) {
90557       {
90558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90559       };
90560     } catch (...) {
90561       {
90562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90563       };
90564     }
90565   }
90566
90567   jresult = (void *)result;
90568   return jresult;
90569 }
90570
90571
90572 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_1(void * jarg1) {
90573   void * jresult ;
90574   Dali::Toolkit::PageTurnPortraitView *arg1 = 0 ;
90575   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
90576
90577   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
90578   if (!arg1) {
90579     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
90580     return 0;
90581   }
90582   {
90583     try {
90584       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView((Dali::Toolkit::PageTurnPortraitView const &)*arg1);
90585     } catch (std::out_of_range& e) {
90586       {
90587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90588       };
90589     } catch (std::exception& e) {
90590       {
90591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90592       };
90593     } catch (Dali::DaliException e) {
90594       {
90595         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90596       };
90597     } catch (...) {
90598       {
90599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90600       };
90601     }
90602   }
90603
90604   jresult = (void *)result;
90605   return jresult;
90606 }
90607
90608
90609 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_Assign(void * jarg1, void * jarg2) {
90610   void * jresult ;
90611   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
90612   Dali::Toolkit::PageTurnPortraitView *arg2 = 0 ;
90613   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
90614
90615   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
90616   arg2 = (Dali::Toolkit::PageTurnPortraitView *)jarg2;
90617   if (!arg2) {
90618     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
90619     return 0;
90620   }
90621   {
90622     try {
90623       result = (Dali::Toolkit::PageTurnPortraitView *) &(arg1)->operator =((Dali::Toolkit::PageTurnPortraitView const &)*arg2);
90624     } catch (std::out_of_range& e) {
90625       {
90626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90627       };
90628     } catch (std::exception& e) {
90629       {
90630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90631       };
90632     } catch (Dali::DaliException e) {
90633       {
90634         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90635       };
90636     } catch (...) {
90637       {
90638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90639       };
90640     }
90641   }
90642
90643   jresult = (void *)result;
90644   return jresult;
90645 }
90646
90647
90648 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnPortraitView(void * jarg1) {
90649   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
90650
90651   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
90652   {
90653     try {
90654       delete arg1;
90655     } catch (std::out_of_range& e) {
90656       {
90657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90658       };
90659     } catch (std::exception& e) {
90660       {
90661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90662       };
90663     } catch (Dali::DaliException e) {
90664       {
90665         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90666       };
90667     } catch (...) {
90668       {
90669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90670       };
90671     }
90672   }
90673
90674 }
90675
90676
90677 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_New(void * jarg1, void * jarg2) {
90678   void * jresult ;
90679   Dali::Toolkit::PageFactory *arg1 = 0 ;
90680   Dali::Vector2 *arg2 = 0 ;
90681   Dali::Toolkit::PageTurnPortraitView result;
90682
90683   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
90684   if (!arg1) {
90685     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
90686     return 0;
90687   }
90688   arg2 = (Dali::Vector2 *)jarg2;
90689   if (!arg2) {
90690     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
90691     return 0;
90692   }
90693   {
90694     try {
90695       result = Dali::Toolkit::PageTurnPortraitView::New(*arg1,(Dali::Vector2 const &)*arg2);
90696     } catch (std::out_of_range& e) {
90697       {
90698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90699       };
90700     } catch (std::exception& e) {
90701       {
90702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90703       };
90704     } catch (Dali::DaliException e) {
90705       {
90706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90707       };
90708     } catch (...) {
90709       {
90710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90711       };
90712     }
90713   }
90714
90715   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
90716   return jresult;
90717 }
90718
90719
90720 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_DownCast(void * jarg1) {
90721   void * jresult ;
90722   Dali::BaseHandle arg1 ;
90723   Dali::BaseHandle *argp1 ;
90724   Dali::Toolkit::PageTurnPortraitView result;
90725
90726   argp1 = (Dali::BaseHandle *)jarg1;
90727   if (!argp1) {
90728     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
90729     return 0;
90730   }
90731   arg1 = *argp1;
90732   {
90733     try {
90734       result = Dali::Toolkit::PageTurnPortraitView::DownCast(arg1);
90735     } catch (std::out_of_range& e) {
90736       {
90737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90738       };
90739     } catch (std::exception& e) {
90740       {
90741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90742       };
90743     } catch (Dali::DaliException e) {
90744       {
90745         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90746       };
90747     } catch (...) {
90748       {
90749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90750       };
90751     }
90752   }
90753
90754   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
90755   return jresult;
90756 }
90757
90758
90759 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_STATE_VISUALS_get() {
90760   int jresult ;
90761   int result;
90762
90763   result = (int)Dali::Toolkit::ToggleButton::Property::STATE_VISUALS;
90764   jresult = (int)result;
90765   return jresult;
90766 }
90767
90768
90769 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_TOOLTIPS_get() {
90770   int jresult ;
90771   int result;
90772
90773   result = (int)Dali::Toolkit::ToggleButton::Property::TOOLTIPS;
90774   jresult = (int)result;
90775   return jresult;
90776 }
90777
90778
90779 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_CURRENT_STATE_INDEX_get() {
90780   int jresult ;
90781   int result;
90782
90783   result = (int)Dali::Toolkit::ToggleButton::Property::CURRENT_STATE_INDEX;
90784   jresult = (int)result;
90785   return jresult;
90786 }
90787
90788
90789 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton_Property() {
90790   void * jresult ;
90791   Dali::Toolkit::ToggleButton::Property *result = 0 ;
90792
90793   {
90794     try {
90795       result = (Dali::Toolkit::ToggleButton::Property *)new Dali::Toolkit::ToggleButton::Property();
90796     } catch (std::out_of_range& e) {
90797       {
90798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90799       };
90800     } catch (std::exception& e) {
90801       {
90802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90803       };
90804     } catch (Dali::DaliException e) {
90805       {
90806         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90807       };
90808     } catch (...) {
90809       {
90810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90811       };
90812     }
90813   }
90814
90815   jresult = (void *)result;
90816   return jresult;
90817 }
90818
90819
90820 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton_Property(void * jarg1) {
90821   Dali::Toolkit::ToggleButton::Property *arg1 = (Dali::Toolkit::ToggleButton::Property *) 0 ;
90822
90823   arg1 = (Dali::Toolkit::ToggleButton::Property *)jarg1;
90824   {
90825     try {
90826       delete arg1;
90827     } catch (std::out_of_range& e) {
90828       {
90829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90830       };
90831     } catch (std::exception& e) {
90832       {
90833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90834       };
90835     } catch (Dali::DaliException e) {
90836       {
90837         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90838       };
90839     } catch (...) {
90840       {
90841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90842       };
90843     }
90844   }
90845
90846 }
90847
90848
90849 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_0() {
90850   void * jresult ;
90851   Dali::Toolkit::ToggleButton *result = 0 ;
90852
90853   {
90854     try {
90855       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton();
90856     } catch (std::out_of_range& e) {
90857       {
90858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90859       };
90860     } catch (std::exception& e) {
90861       {
90862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90863       };
90864     } catch (Dali::DaliException e) {
90865       {
90866         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90867       };
90868     } catch (...) {
90869       {
90870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90871       };
90872     }
90873   }
90874
90875   jresult = (void *)result;
90876   return jresult;
90877 }
90878
90879
90880 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_1(void * jarg1) {
90881   void * jresult ;
90882   Dali::Toolkit::ToggleButton *arg1 = 0 ;
90883   Dali::Toolkit::ToggleButton *result = 0 ;
90884
90885   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
90886   if (!arg1) {
90887     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
90888     return 0;
90889   }
90890   {
90891     try {
90892       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton((Dali::Toolkit::ToggleButton const &)*arg1);
90893     } catch (std::out_of_range& e) {
90894       {
90895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90896       };
90897     } catch (std::exception& e) {
90898       {
90899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90900       };
90901     } catch (Dali::DaliException e) {
90902       {
90903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90904       };
90905     } catch (...) {
90906       {
90907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90908       };
90909     }
90910   }
90911
90912   jresult = (void *)result;
90913   return jresult;
90914 }
90915
90916
90917 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_Assign(void * jarg1, void * jarg2) {
90918   void * jresult ;
90919   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
90920   Dali::Toolkit::ToggleButton *arg2 = 0 ;
90921   Dali::Toolkit::ToggleButton *result = 0 ;
90922
90923   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
90924   arg2 = (Dali::Toolkit::ToggleButton *)jarg2;
90925   if (!arg2) {
90926     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
90927     return 0;
90928   }
90929   {
90930     try {
90931       result = (Dali::Toolkit::ToggleButton *) &(arg1)->operator =((Dali::Toolkit::ToggleButton const &)*arg2);
90932     } catch (std::out_of_range& e) {
90933       {
90934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90935       };
90936     } catch (std::exception& e) {
90937       {
90938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90939       };
90940     } catch (Dali::DaliException e) {
90941       {
90942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90943       };
90944     } catch (...) {
90945       {
90946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90947       };
90948     }
90949   }
90950
90951   jresult = (void *)result;
90952   return jresult;
90953 }
90954
90955
90956 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton(void * jarg1) {
90957   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
90958
90959   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
90960   {
90961     try {
90962       delete arg1;
90963     } catch (std::out_of_range& e) {
90964       {
90965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90966       };
90967     } catch (std::exception& e) {
90968       {
90969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90970       };
90971     } catch (Dali::DaliException e) {
90972       {
90973         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90974       };
90975     } catch (...) {
90976       {
90977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90978       };
90979     }
90980   }
90981
90982 }
90983
90984
90985 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_New() {
90986   void * jresult ;
90987   Dali::Toolkit::ToggleButton result;
90988
90989   {
90990     try {
90991       result = Dali::Toolkit::ToggleButton::New();
90992     } catch (std::out_of_range& e) {
90993       {
90994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90995       };
90996     } catch (std::exception& e) {
90997       {
90998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90999       };
91000     } catch (Dali::DaliException e) {
91001       {
91002         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91003       };
91004     } catch (...) {
91005       {
91006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91007       };
91008     }
91009   }
91010
91011   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
91012   return jresult;
91013 }
91014
91015
91016 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_DownCast(void * jarg1) {
91017   void * jresult ;
91018   Dali::BaseHandle arg1 ;
91019   Dali::BaseHandle *argp1 ;
91020   Dali::Toolkit::ToggleButton result;
91021
91022   argp1 = (Dali::BaseHandle *)jarg1;
91023   if (!argp1) {
91024     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
91025     return 0;
91026   }
91027   arg1 = *argp1;
91028   {
91029     try {
91030       result = Dali::Toolkit::ToggleButton::DownCast(arg1);
91031     } catch (std::out_of_range& e) {
91032       {
91033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91034       };
91035     } catch (std::exception& e) {
91036       {
91037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91038       };
91039     } catch (Dali::DaliException e) {
91040       {
91041         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91042       };
91043     } catch (...) {
91044       {
91045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91046       };
91047     }
91048   }
91049
91050   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
91051   return jresult;
91052 }
91053
91054
91055 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_0() {
91056   void * jresult ;
91057   Dali::Toolkit::Visual::Base *result = 0 ;
91058
91059   {
91060     try {
91061       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base();
91062     } catch (std::out_of_range& e) {
91063       {
91064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91065       };
91066     } catch (std::exception& e) {
91067       {
91068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91069       };
91070     } catch (Dali::DaliException e) {
91071       {
91072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91073       };
91074     } catch (...) {
91075       {
91076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91077       };
91078     }
91079   }
91080
91081   jresult = (void *)result;
91082   return jresult;
91083 }
91084
91085
91086 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualBase(void * jarg1) {
91087   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91088
91089   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91090   {
91091     try {
91092       delete arg1;
91093     } catch (std::out_of_range& e) {
91094       {
91095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91096       };
91097     } catch (std::exception& e) {
91098       {
91099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91100       };
91101     } catch (Dali::DaliException e) {
91102       {
91103         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91104       };
91105     } catch (...) {
91106       {
91107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91108       };
91109     }
91110   }
91111
91112 }
91113
91114
91115 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_1(void * jarg1) {
91116   void * jresult ;
91117   Dali::Toolkit::Visual::Base *arg1 = 0 ;
91118   Dali::Toolkit::Visual::Base *result = 0 ;
91119
91120   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91121   if (!arg1) {
91122     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
91123     return 0;
91124   }
91125   {
91126     try {
91127       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base((Dali::Toolkit::Visual::Base const &)*arg1);
91128     } catch (std::out_of_range& e) {
91129       {
91130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91131       };
91132     } catch (std::exception& e) {
91133       {
91134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91135       };
91136     } catch (Dali::DaliException e) {
91137       {
91138         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91139       };
91140     } catch (...) {
91141       {
91142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91143       };
91144     }
91145   }
91146
91147   jresult = (void *)result;
91148   return jresult;
91149 }
91150
91151
91152 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualBase_Assign(void * jarg1, void * jarg2) {
91153   void * jresult ;
91154   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91155   Dali::Toolkit::Visual::Base *arg2 = 0 ;
91156   Dali::Toolkit::Visual::Base *result = 0 ;
91157
91158   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91159   arg2 = (Dali::Toolkit::Visual::Base *)jarg2;
91160   if (!arg2) {
91161     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
91162     return 0;
91163   }
91164   {
91165     try {
91166       result = (Dali::Toolkit::Visual::Base *) &(arg1)->operator =((Dali::Toolkit::Visual::Base const &)*arg2);
91167     } catch (std::out_of_range& e) {
91168       {
91169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91170       };
91171     } catch (std::exception& e) {
91172       {
91173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91174       };
91175     } catch (Dali::DaliException e) {
91176       {
91177         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91178       };
91179     } catch (...) {
91180       {
91181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91182       };
91183     }
91184   }
91185
91186   jresult = (void *)result;
91187   return jresult;
91188 }
91189
91190
91191 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetName(void * jarg1, char * jarg2) {
91192   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91193   std::string *arg2 = 0 ;
91194
91195   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91196   if (!jarg2) {
91197     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
91198     return ;
91199   }
91200   std::string arg2_str(jarg2);
91201   arg2 = &arg2_str;
91202   {
91203     try {
91204       (arg1)->SetName((std::string const &)*arg2);
91205     } catch (std::out_of_range& e) {
91206       {
91207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91208       };
91209     } catch (std::exception& e) {
91210       {
91211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91212       };
91213     } catch (Dali::DaliException e) {
91214       {
91215         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91216       };
91217     } catch (...) {
91218       {
91219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91220       };
91221     }
91222   }
91223
91224
91225   //argout typemap for const std::string&
91226
91227 }
91228
91229
91230 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_VisualBase_GetName(void * jarg1) {
91231   char * jresult ;
91232   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91233   std::string *result = 0 ;
91234
91235   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91236   {
91237     try {
91238       result = (std::string *) &(arg1)->GetName();
91239     } catch (std::out_of_range& e) {
91240       {
91241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91242       };
91243     } catch (std::exception& e) {
91244       {
91245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91246       };
91247     } catch (Dali::DaliException e) {
91248       {
91249         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91250       };
91251     } catch (...) {
91252       {
91253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91254       };
91255     }
91256   }
91257
91258   jresult = SWIG_csharp_string_callback(result->c_str());
91259   return jresult;
91260 }
91261
91262
91263 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetTransformAndSize(void * jarg1, void * jarg2, void * jarg3) {
91264   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91265   Dali::Property::Map *arg2 = 0 ;
91266   Dali::Size arg3 ;
91267   Dali::Size *argp3 ;
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 const & type is null", 0);
91273     return ;
91274   }
91275   argp3 = (Dali::Size *)jarg3;
91276   if (!argp3) {
91277     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
91278     return ;
91279   }
91280   arg3 = *argp3;
91281   {
91282     try {
91283       (arg1)->SetTransformAndSize((Dali::Property::Map const &)*arg2,arg3);
91284     } catch (std::out_of_range& e) {
91285       {
91286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91287       };
91288     } catch (std::exception& e) {
91289       {
91290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91291       };
91292     } catch (Dali::DaliException e) {
91293       {
91294         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91295       };
91296     } catch (...) {
91297       {
91298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91299       };
91300     }
91301   }
91302
91303 }
91304
91305
91306 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetHeightForWidth(void * jarg1, float jarg2) {
91307   float jresult ;
91308   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91309   float arg2 ;
91310   float result;
91311
91312   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91313   arg2 = (float)jarg2;
91314   {
91315     try {
91316       result = (float)(arg1)->GetHeightForWidth(arg2);
91317     } catch (std::out_of_range& e) {
91318       {
91319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91320       };
91321     } catch (std::exception& e) {
91322       {
91323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91324       };
91325     } catch (Dali::DaliException e) {
91326       {
91327         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91328       };
91329     } catch (...) {
91330       {
91331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91332       };
91333     }
91334   }
91335
91336   jresult = result;
91337   return jresult;
91338 }
91339
91340
91341 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetWidthForHeight(void * jarg1, float jarg2) {
91342   float jresult ;
91343   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91344   float arg2 ;
91345   float result;
91346
91347   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91348   arg2 = (float)jarg2;
91349   {
91350     try {
91351       result = (float)(arg1)->GetWidthForHeight(arg2);
91352     } catch (std::out_of_range& e) {
91353       {
91354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91355       };
91356     } catch (std::exception& e) {
91357       {
91358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91359       };
91360     } catch (Dali::DaliException e) {
91361       {
91362         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91363       };
91364     } catch (...) {
91365       {
91366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91367       };
91368     }
91369   }
91370
91371   jresult = result;
91372   return jresult;
91373 }
91374
91375
91376 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_GetNaturalSize(void * jarg1, void * jarg2) {
91377   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91378   Dali::Vector2 *arg2 = 0 ;
91379
91380   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91381   arg2 = (Dali::Vector2 *)jarg2;
91382   if (!arg2) {
91383     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
91384     return ;
91385   }
91386   {
91387     try {
91388       (arg1)->GetNaturalSize(*arg2);
91389     } catch (std::out_of_range& e) {
91390       {
91391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91392       };
91393     } catch (std::exception& e) {
91394       {
91395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91396       };
91397     } catch (Dali::DaliException e) {
91398       {
91399         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91400       };
91401     } catch (...) {
91402       {
91403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91404       };
91405     }
91406   }
91407
91408 }
91409
91410
91411 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetDepthIndex(void * jarg1, int jarg2) {
91412   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91413   float arg2 ;
91414
91415   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91416   arg2 = (int)jarg2;
91417   {
91418     try {
91419       (arg1)->SetDepthIndex(arg2);
91420     } catch (std::out_of_range& e) {
91421       {
91422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91423       };
91424     } catch (std::exception& e) {
91425       {
91426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91427       };
91428     } catch (Dali::DaliException e) {
91429       {
91430         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91431       };
91432     } catch (...) {
91433       {
91434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91435       };
91436     }
91437   }
91438
91439 }
91440
91441
91442 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VisualBase_GetDepthIndex(void * jarg1) {
91443   int jresult ;
91444   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91445   int result;
91446
91447   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91448   {
91449     try {
91450       result = (float)((Dali::Toolkit::Visual::Base const *)arg1)->GetDepthIndex();
91451     } catch (std::out_of_range& e) {
91452       {
91453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91454       };
91455     } catch (std::exception& e) {
91456       {
91457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91458       };
91459     } catch (Dali::DaliException e) {
91460       {
91461         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91462       };
91463     } catch (...) {
91464       {
91465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91466       };
91467     }
91468   }
91469
91470   jresult = result;
91471   return jresult;
91472 }
91473
91474
91475 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_CreatePropertyMap(void * jarg1, void * jarg2) {
91476   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91477   Dali::Property::Map *arg2 = 0 ;
91478
91479   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91480   arg2 = (Dali::Property::Map *)jarg2;
91481   if (!arg2) {
91482     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
91483     return ;
91484   }
91485   {
91486     try {
91487       ((Dali::Toolkit::Visual::Base const *)arg1)->CreatePropertyMap(*arg2);
91488     } catch (std::out_of_range& e) {
91489       {
91490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91491       };
91492     } catch (std::exception& e) {
91493       {
91494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91495       };
91496     } catch (Dali::DaliException e) {
91497       {
91498         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91499       };
91500     } catch (...) {
91501       {
91502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91503       };
91504     }
91505   }
91506
91507 }
91508
91509
91510 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Get() {
91511   void * jresult ;
91512   Dali::Toolkit::VisualFactory result;
91513
91514   {
91515     try {
91516       result = Dali::Toolkit::VisualFactory::Get();
91517     } catch (std::out_of_range& e) {
91518       {
91519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91520       };
91521     } catch (std::exception& e) {
91522       {
91523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91524       };
91525     } catch (Dali::DaliException e) {
91526       {
91527         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91528       };
91529     } catch (...) {
91530       {
91531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91532       };
91533     }
91534   }
91535
91536   jresult = new Dali::Toolkit::VisualFactory((const Dali::Toolkit::VisualFactory &)result);
91537   return jresult;
91538 }
91539
91540
91541 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_0() {
91542   void * jresult ;
91543   Dali::Toolkit::VisualFactory *result = 0 ;
91544
91545   {
91546     try {
91547       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory();
91548     } catch (std::out_of_range& e) {
91549       {
91550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91551       };
91552     } catch (std::exception& e) {
91553       {
91554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91555       };
91556     } catch (Dali::DaliException e) {
91557       {
91558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91559       };
91560     } catch (...) {
91561       {
91562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91563       };
91564     }
91565   }
91566
91567   jresult = (void *)result;
91568   return jresult;
91569 }
91570
91571
91572 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualFactory(void * jarg1) {
91573   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
91574
91575   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91576   {
91577     try {
91578       delete arg1;
91579     } catch (std::out_of_range& e) {
91580       {
91581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91582       };
91583     } catch (std::exception& e) {
91584       {
91585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91586       };
91587     } catch (Dali::DaliException e) {
91588       {
91589         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91590       };
91591     } catch (...) {
91592       {
91593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91594       };
91595     }
91596   }
91597
91598 }
91599
91600
91601 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_1(void * jarg1) {
91602   void * jresult ;
91603   Dali::Toolkit::VisualFactory *arg1 = 0 ;
91604   Dali::Toolkit::VisualFactory *result = 0 ;
91605
91606   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91607   if (!arg1) {
91608     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
91609     return 0;
91610   }
91611   {
91612     try {
91613       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory((Dali::Toolkit::VisualFactory const &)*arg1);
91614     } catch (std::out_of_range& e) {
91615       {
91616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91617       };
91618     } catch (std::exception& e) {
91619       {
91620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91621       };
91622     } catch (Dali::DaliException e) {
91623       {
91624         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91625       };
91626     } catch (...) {
91627       {
91628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91629       };
91630     }
91631   }
91632
91633   jresult = (void *)result;
91634   return jresult;
91635 }
91636
91637
91638 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Assign(void * jarg1, void * jarg2) {
91639   void * jresult ;
91640   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
91641   Dali::Toolkit::VisualFactory *arg2 = 0 ;
91642   Dali::Toolkit::VisualFactory *result = 0 ;
91643
91644   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91645   arg2 = (Dali::Toolkit::VisualFactory *)jarg2;
91646   if (!arg2) {
91647     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
91648     return 0;
91649   }
91650   {
91651     try {
91652       result = (Dali::Toolkit::VisualFactory *) &(arg1)->operator =((Dali::Toolkit::VisualFactory const &)*arg2);
91653     } catch (std::out_of_range& e) {
91654       {
91655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91656       };
91657     } catch (std::exception& e) {
91658       {
91659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91660       };
91661     } catch (Dali::DaliException e) {
91662       {
91663         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91664       };
91665     } catch (...) {
91666       {
91667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91668       };
91669     }
91670   }
91671
91672   jresult = (void *)result;
91673   return jresult;
91674 }
91675
91676
91677 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_0(void * jarg1, void * jarg2) {
91678   void * jresult ;
91679   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
91680   Dali::Property::Map *arg2 = 0 ;
91681   Dali::Toolkit::Visual::Base result;
91682
91683   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91684   arg2 = (Dali::Property::Map *)jarg2;
91685   if (!arg2) {
91686     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
91687     return 0;
91688   }
91689   {
91690     try {
91691       result = (arg1)->CreateVisual((Dali::Property::Map const &)*arg2);
91692     } catch (std::out_of_range& e) {
91693       {
91694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91695       };
91696     } catch (std::exception& e) {
91697       {
91698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91699       };
91700     } catch (Dali::DaliException e) {
91701       {
91702         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91703       };
91704     } catch (...) {
91705       {
91706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91707       };
91708     }
91709   }
91710
91711   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
91712   return jresult;
91713 }
91714
91715
91716 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_1(void * jarg1, void * jarg2) {
91717   void * jresult ;
91718   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
91719   Dali::Image *arg2 = 0 ;
91720   Dali::Toolkit::Visual::Base result;
91721
91722   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91723   arg2 = (Dali::Image *)jarg2;
91724   if (!arg2) {
91725     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
91726     return 0;
91727   }
91728   {
91729     try {
91730       result = (arg1)->CreateVisual((Dali::Image const &)*arg2);
91731     } catch (std::out_of_range& e) {
91732       {
91733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91734       };
91735     } catch (std::exception& e) {
91736       {
91737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91738       };
91739     } catch (Dali::DaliException e) {
91740       {
91741         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91742       };
91743     } catch (...) {
91744       {
91745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91746       };
91747     }
91748   }
91749
91750   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
91751   return jresult;
91752 }
91753
91754
91755 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
91756   void * jresult ;
91757   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
91758   std::string *arg2 = 0 ;
91759   Dali::ImageDimensions arg3 ;
91760   Dali::ImageDimensions *argp3 ;
91761   Dali::Toolkit::Visual::Base result;
91762
91763   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91764   if (!jarg2) {
91765     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
91766     return 0;
91767   }
91768   std::string arg2_str(jarg2);
91769   arg2 = &arg2_str;
91770   argp3 = (Dali::ImageDimensions *)jarg3;
91771   if (!argp3) {
91772     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
91773     return 0;
91774   }
91775   arg3 = *argp3;
91776   {
91777     try {
91778       result = (arg1)->CreateVisual((std::string const &)*arg2,arg3);
91779     } catch (std::out_of_range& e) {
91780       {
91781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91782       };
91783     } catch (std::exception& e) {
91784       {
91785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91786       };
91787     } catch (Dali::DaliException e) {
91788       {
91789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91790       };
91791     } catch (...) {
91792       {
91793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91794       };
91795     }
91796   }
91797
91798   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
91799
91800   //argout typemap for const std::string&
91801
91802   return jresult;
91803 }
91804
91805
91806 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_0() {
91807   void * jresult ;
91808   Dali::Toolkit::AsyncImageLoader *result = 0 ;
91809
91810   {
91811     try {
91812       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader();
91813     } catch (std::out_of_range& e) {
91814       {
91815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91816       };
91817     } catch (std::exception& e) {
91818       {
91819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91820       };
91821     } catch (Dali::DaliException e) {
91822       {
91823         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91824       };
91825     } catch (...) {
91826       {
91827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91828       };
91829     }
91830   }
91831
91832   jresult = (void *)result;
91833   return jresult;
91834 }
91835
91836
91837 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AsyncImageLoader(void * jarg1) {
91838   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
91839
91840   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
91841   {
91842     try {
91843       delete arg1;
91844     } catch (std::out_of_range& e) {
91845       {
91846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91847       };
91848     } catch (std::exception& e) {
91849       {
91850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91851       };
91852     } catch (Dali::DaliException e) {
91853       {
91854         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91855       };
91856     } catch (...) {
91857       {
91858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91859       };
91860     }
91861   }
91862
91863 }
91864
91865
91866 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_1(void * jarg1) {
91867   void * jresult ;
91868   Dali::Toolkit::AsyncImageLoader *arg1 = 0 ;
91869   Dali::Toolkit::AsyncImageLoader *result = 0 ;
91870
91871   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
91872   if (!arg1) {
91873     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
91874     return 0;
91875   }
91876   {
91877     try {
91878       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader((Dali::Toolkit::AsyncImageLoader const &)*arg1);
91879     } catch (std::out_of_range& e) {
91880       {
91881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91882       };
91883     } catch (std::exception& e) {
91884       {
91885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91886       };
91887     } catch (Dali::DaliException e) {
91888       {
91889         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91890       };
91891     } catch (...) {
91892       {
91893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91894       };
91895     }
91896   }
91897
91898   jresult = (void *)result;
91899   return jresult;
91900 }
91901
91902
91903 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Assign(void * jarg1, void * jarg2) {
91904   void * jresult ;
91905   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
91906   Dali::Toolkit::AsyncImageLoader *arg2 = 0 ;
91907   Dali::Toolkit::AsyncImageLoader *result = 0 ;
91908
91909   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
91910   arg2 = (Dali::Toolkit::AsyncImageLoader *)jarg2;
91911   if (!arg2) {
91912     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
91913     return 0;
91914   }
91915   {
91916     try {
91917       result = (Dali::Toolkit::AsyncImageLoader *) &(arg1)->operator =((Dali::Toolkit::AsyncImageLoader const &)*arg2);
91918     } catch (std::out_of_range& e) {
91919       {
91920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91921       };
91922     } catch (std::exception& e) {
91923       {
91924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91925       };
91926     } catch (Dali::DaliException e) {
91927       {
91928         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91929       };
91930     } catch (...) {
91931       {
91932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91933       };
91934     }
91935   }
91936
91937   jresult = (void *)result;
91938   return jresult;
91939 }
91940
91941
91942 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_New() {
91943   void * jresult ;
91944   Dali::Toolkit::AsyncImageLoader result;
91945
91946   {
91947     try {
91948       result = Dali::Toolkit::AsyncImageLoader::New();
91949     } catch (std::out_of_range& e) {
91950       {
91951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91952       };
91953     } catch (std::exception& e) {
91954       {
91955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91956       };
91957     } catch (Dali::DaliException e) {
91958       {
91959         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91960       };
91961     } catch (...) {
91962       {
91963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91964       };
91965     }
91966   }
91967
91968   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
91969   return jresult;
91970 }
91971
91972
91973 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_DownCast(void * jarg1) {
91974   void * jresult ;
91975   Dali::BaseHandle arg1 ;
91976   Dali::BaseHandle *argp1 ;
91977   Dali::Toolkit::AsyncImageLoader result;
91978
91979   argp1 = (Dali::BaseHandle *)jarg1;
91980   if (!argp1) {
91981     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
91982     return 0;
91983   }
91984   arg1 = *argp1;
91985   {
91986     try {
91987       result = Dali::Toolkit::AsyncImageLoader::DownCast(arg1);
91988     } catch (std::out_of_range& e) {
91989       {
91990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91991       };
91992     } catch (std::exception& e) {
91993       {
91994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91995       };
91996     } catch (Dali::DaliException e) {
91997       {
91998         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91999       };
92000     } catch (...) {
92001       {
92002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92003       };
92004     }
92005   }
92006
92007   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
92008   return jresult;
92009 }
92010
92011
92012 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_0(void * jarg1, char * jarg2) {
92013   unsigned int jresult ;
92014   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
92015   std::string *arg2 = 0 ;
92016   uint32_t result;
92017
92018   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92019   if (!jarg2) {
92020     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
92021     return 0;
92022   }
92023   std::string arg2_str(jarg2);
92024   arg2 = &arg2_str;
92025   {
92026     try {
92027       result = (arg1)->Load((std::string const &)*arg2);
92028     } catch (std::out_of_range& e) {
92029       {
92030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92031       };
92032     } catch (std::exception& e) {
92033       {
92034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92035       };
92036     } catch (Dali::DaliException e) {
92037       {
92038         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92039       };
92040     } catch (...) {
92041       {
92042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92043       };
92044     }
92045   }
92046
92047   jresult = result;
92048
92049   //argout typemap for const std::string&
92050
92051   return jresult;
92052 }
92053
92054
92055 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
92056   unsigned int jresult ;
92057   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
92058   std::string *arg2 = 0 ;
92059   Dali::ImageDimensions arg3 ;
92060   Dali::ImageDimensions *argp3 ;
92061   uint32_t result;
92062
92063   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92064   if (!jarg2) {
92065     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
92066     return 0;
92067   }
92068   std::string arg2_str(jarg2);
92069   arg2 = &arg2_str;
92070   argp3 = (Dali::ImageDimensions *)jarg3;
92071   if (!argp3) {
92072     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
92073     return 0;
92074   }
92075   arg3 = *argp3;
92076   {
92077     try {
92078       result = (arg1)->Load((std::string const &)*arg2,arg3);
92079     } catch (std::out_of_range& e) {
92080       {
92081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92082       };
92083     } catch (std::exception& e) {
92084       {
92085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92086       };
92087     } catch (Dali::DaliException e) {
92088       {
92089         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92090       };
92091     } catch (...) {
92092       {
92093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92094       };
92095     }
92096   }
92097
92098   jresult = result;
92099
92100   //argout typemap for const std::string&
92101
92102   return jresult;
92103 }
92104
92105
92106 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_2(void * jarg1, char * jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
92107   unsigned int jresult ;
92108   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
92109   std::string *arg2 = 0 ;
92110   Dali::ImageDimensions arg3 ;
92111   Dali::FittingMode::Type arg4 ;
92112   Dali::SamplingMode::Type arg5 ;
92113   bool arg6 ;
92114   Dali::ImageDimensions *argp3 ;
92115   uint32_t result;
92116
92117   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92118   if (!jarg2) {
92119     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
92120     return 0;
92121   }
92122   std::string arg2_str(jarg2);
92123   arg2 = &arg2_str;
92124   argp3 = (Dali::ImageDimensions *)jarg3;
92125   if (!argp3) {
92126     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
92127     return 0;
92128   }
92129   arg3 = *argp3;
92130   arg4 = (Dali::FittingMode::Type)jarg4;
92131   arg5 = (Dali::SamplingMode::Type)jarg5;
92132   arg6 = jarg6 ? true : false;
92133   {
92134     try {
92135       result = (arg1)->Load((std::string const &)*arg2,arg3,arg4,arg5,arg6);
92136     } catch (std::out_of_range& e) {
92137       {
92138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92139       };
92140     } catch (std::exception& e) {
92141       {
92142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92143       };
92144     } catch (Dali::DaliException e) {
92145       {
92146         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92147       };
92148     } catch (...) {
92149       {
92150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92151       };
92152     }
92153   }
92154
92155   jresult = result;
92156
92157   //argout typemap for const std::string&
92158
92159   return jresult;
92160 }
92161
92162
92163 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Cancel(void * jarg1, unsigned int jarg2) {
92164   unsigned int jresult ;
92165   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
92166   uint32_t arg2 ;
92167   bool result;
92168
92169   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92170   arg2 = (uint32_t)jarg2;
92171   {
92172     try {
92173       result = (bool)(arg1)->Cancel(arg2);
92174     } catch (std::out_of_range& e) {
92175       {
92176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92177       };
92178     } catch (std::exception& e) {
92179       {
92180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92181       };
92182     } catch (Dali::DaliException e) {
92183       {
92184         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92185       };
92186     } catch (...) {
92187       {
92188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92189       };
92190     }
92191   }
92192
92193   jresult = result;
92194   return jresult;
92195 }
92196
92197
92198 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AsyncImageLoader_CancelAll(void * jarg1) {
92199   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
92200
92201   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92202   {
92203     try {
92204       (arg1)->CancelAll();
92205     } catch (std::out_of_range& e) {
92206       {
92207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92208       };
92209     } catch (std::exception& e) {
92210       {
92211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92212       };
92213     } catch (Dali::DaliException e) {
92214       {
92215         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92216       };
92217     } catch (...) {
92218       {
92219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92220       };
92221     }
92222   }
92223
92224 }
92225
92226
92227 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_ImageLoadedSignal(void * jarg1) {
92228   void * jresult ;
92229   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
92230   Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *result = 0 ;
92231
92232   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92233   {
92234     try {
92235       result = (Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *) &(arg1)->ImageLoadedSignal();
92236     } catch (std::out_of_range& e) {
92237       {
92238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92239       };
92240     } catch (std::exception& e) {
92241       {
92242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92243       };
92244     } catch (Dali::DaliException e) {
92245       {
92246         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92247       };
92248     } catch (...) {
92249       {
92250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92251       };
92252     }
92253   }
92254
92255   jresult = (void *)result;
92256   return jresult;
92257 }
92258
92259
92260 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_0(char * jarg1) {
92261   void * jresult ;
92262   std::string *arg1 = 0 ;
92263   Dali::PixelData result;
92264
92265   if (!jarg1) {
92266     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
92267     return 0;
92268   }
92269   std::string arg1_str(jarg1);
92270   arg1 = &arg1_str;
92271   {
92272     try {
92273       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1);
92274     } catch (std::out_of_range& e) {
92275       {
92276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92277       };
92278     } catch (std::exception& e) {
92279       {
92280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92281       };
92282     } catch (Dali::DaliException e) {
92283       {
92284         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92285       };
92286     } catch (...) {
92287       {
92288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92289       };
92290     }
92291   }
92292
92293   jresult = new Dali::PixelData((const Dali::PixelData &)result);
92294
92295   //argout typemap for const std::string&
92296
92297   return jresult;
92298 }
92299
92300
92301 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_1(char * jarg1, void * jarg2) {
92302   void * jresult ;
92303   std::string *arg1 = 0 ;
92304   Dali::ImageDimensions arg2 ;
92305   Dali::ImageDimensions *argp2 ;
92306   Dali::PixelData result;
92307
92308   if (!jarg1) {
92309     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
92310     return 0;
92311   }
92312   std::string arg1_str(jarg1);
92313   arg1 = &arg1_str;
92314   argp2 = (Dali::ImageDimensions *)jarg2;
92315   if (!argp2) {
92316     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
92317     return 0;
92318   }
92319   arg2 = *argp2;
92320   {
92321     try {
92322       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2);
92323     } catch (std::out_of_range& e) {
92324       {
92325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92326       };
92327     } catch (std::exception& e) {
92328       {
92329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92330       };
92331     } catch (Dali::DaliException e) {
92332       {
92333         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92334       };
92335     } catch (...) {
92336       {
92337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92338       };
92339     }
92340   }
92341
92342   jresult = new Dali::PixelData((const Dali::PixelData &)result);
92343
92344   //argout typemap for const std::string&
92345
92346   return jresult;
92347 }
92348
92349
92350 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
92351   void * jresult ;
92352   std::string *arg1 = 0 ;
92353   Dali::ImageDimensions arg2 ;
92354   Dali::FittingMode::Type arg3 ;
92355   Dali::SamplingMode::Type arg4 ;
92356   bool arg5 ;
92357   Dali::ImageDimensions *argp2 ;
92358   Dali::PixelData result;
92359
92360   if (!jarg1) {
92361     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
92362     return 0;
92363   }
92364   std::string arg1_str(jarg1);
92365   arg1 = &arg1_str;
92366   argp2 = (Dali::ImageDimensions *)jarg2;
92367   if (!argp2) {
92368     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
92369     return 0;
92370   }
92371   arg2 = *argp2;
92372   arg3 = (Dali::FittingMode::Type)jarg3;
92373   arg4 = (Dali::SamplingMode::Type)jarg4;
92374   arg5 = jarg5 ? true : false;
92375   {
92376     try {
92377       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2,arg3,arg4,arg5);
92378     } catch (std::out_of_range& e) {
92379       {
92380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92381       };
92382     } catch (std::exception& e) {
92383       {
92384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92385       };
92386     } catch (Dali::DaliException e) {
92387       {
92388         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92389       };
92390     } catch (...) {
92391       {
92392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92393       };
92394     }
92395   }
92396
92397   jresult = new Dali::PixelData((const Dali::PixelData &)result);
92398
92399   //argout typemap for const std::string&
92400
92401   return jresult;
92402 }
92403
92404
92405 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomAlgorithmInterface(void * jarg1) {
92406   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
92407
92408   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
92409   {
92410     try {
92411       delete arg1;
92412     } catch (std::out_of_range& e) {
92413       {
92414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92415       };
92416     } catch (std::exception& e) {
92417       {
92418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92419       };
92420     } catch (Dali::DaliException e) {
92421       {
92422         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92423       };
92424     } catch (...) {
92425       {
92426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92427       };
92428     }
92429   }
92430
92431 }
92432
92433
92434 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_GetNextFocusableActor(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
92435   void * jresult ;
92436   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
92437   Dali::Actor arg2 ;
92438   Dali::Actor arg3 ;
92439   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
92440   Dali::Actor *argp2 ;
92441   Dali::Actor *argp3 ;
92442   Dali::Actor result;
92443
92444   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
92445   argp2 = (Dali::Actor *)jarg2;
92446   if (!argp2) {
92447     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
92448     return 0;
92449   }
92450   arg2 = *argp2;
92451   argp3 = (Dali::Actor *)jarg3;
92452   if (!argp3) {
92453     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
92454     return 0;
92455   }
92456   arg3 = *argp3;
92457   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
92458   {
92459     try {
92460       result = (arg1)->GetNextFocusableActor(arg2,arg3,arg4);
92461     } catch (std::out_of_range& e) {
92462       {
92463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92464       };
92465     } catch (std::exception& e) {
92466       {
92467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92468       };
92469     } catch (Dali::DaliException e) {
92470       {
92471         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92472       };
92473     } catch (...) {
92474       {
92475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92476       };
92477     }
92478   }
92479
92480   jresult = new Dali::Actor((const Dali::Actor &)result);
92481   return jresult;
92482 }
92483
92484
92485 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomAlgorithmInterface() {
92486   void * jresult ;
92487   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *result = 0 ;
92488
92489   {
92490     try {
92491       result = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)new SwigDirector_CustomAlgorithmInterface();
92492     } catch (std::out_of_range& e) {
92493       {
92494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92495       };
92496     } catch (std::exception& e) {
92497       {
92498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92499       };
92500     } catch (Dali::DaliException e) {
92501       {
92502         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92503       };
92504     } catch (...) {
92505       {
92506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92507       };
92508     }
92509   }
92510
92511   jresult = (void *)result;
92512   return jresult;
92513 }
92514
92515
92516 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_director_connect(void *objarg, SwigDirector_CustomAlgorithmInterface::SWIG_Callback0_t callback0) {
92517   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *obj = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)objarg;
92518   SwigDirector_CustomAlgorithmInterface *director = dynamic_cast<SwigDirector_CustomAlgorithmInterface *>(obj);
92519   if (director) {
92520     director->swig_connect_director(callback0);
92521   }
92522 }
92523
92524
92525 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetCustomAlgorithm(void * jarg1, void * jarg2) {
92526   KeyboardFocusManager arg1 ;
92527   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg2 = 0 ;
92528   KeyboardFocusManager *argp1 ;
92529
92530   argp1 = (KeyboardFocusManager *)jarg1;
92531   if (!argp1) {
92532     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null KeyboardFocusManager", 0);
92533     return ;
92534   }
92535   arg1 = *argp1;
92536   arg2 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg2;
92537   if (!arg2) {
92538     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface & type is null", 0);
92539     return ;
92540   }
92541   {
92542     try {
92543       Dali::Toolkit::DevelKeyboardFocusManager::SetCustomAlgorithm(arg1,*arg2);
92544     } catch (std::out_of_range& e) {
92545       {
92546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92547       };
92548     } catch (std::exception& e) {
92549       {
92550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92551       };
92552     } catch (Dali::DaliException e) {
92553       {
92554         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92555       };
92556     } catch (...) {
92557       {
92558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92559       };
92560     }
92561   }
92562
92563 }
92564
92565
92566 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Clear(void * jarg1) {
92567   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92568
92569   arg1 = (std::vector< unsigned int > *)jarg1;
92570   {
92571     try {
92572       (arg1)->clear();
92573     } catch (std::out_of_range& e) {
92574       {
92575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92576       };
92577     } catch (std::exception& e) {
92578       {
92579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92580       };
92581     } catch (Dali::DaliException e) {
92582       {
92583         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92584       };
92585     } catch (...) {
92586       {
92587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92588       };
92589     }
92590   }
92591
92592 }
92593
92594
92595 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Add(void * jarg1, unsigned int jarg2) {
92596   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92597   unsigned int *arg2 = 0 ;
92598   unsigned int temp2 ;
92599
92600   arg1 = (std::vector< unsigned int > *)jarg1;
92601   temp2 = (unsigned int)jarg2;
92602   arg2 = &temp2;
92603   {
92604     try {
92605       (arg1)->push_back((unsigned int const &)*arg2);
92606     } catch (std::out_of_range& e) {
92607       {
92608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92609       };
92610     } catch (std::exception& e) {
92611       {
92612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92613       };
92614     } catch (Dali::DaliException e) {
92615       {
92616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92617       };
92618     } catch (...) {
92619       {
92620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92621       };
92622     }
92623   }
92624
92625 }
92626
92627
92628 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_size(void * jarg1) {
92629   unsigned long jresult ;
92630   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92631   std::vector< unsigned int >::size_type result;
92632
92633   arg1 = (std::vector< unsigned int > *)jarg1;
92634   {
92635     try {
92636       result = ((std::vector< unsigned int > const *)arg1)->size();
92637     } catch (std::out_of_range& e) {
92638       {
92639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92640       };
92641     } catch (std::exception& e) {
92642       {
92643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92644       };
92645     } catch (Dali::DaliException e) {
92646       {
92647         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92648       };
92649     } catch (...) {
92650       {
92651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92652       };
92653     }
92654   }
92655
92656   jresult = (unsigned long)result;
92657   return jresult;
92658 }
92659
92660
92661 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_capacity(void * jarg1) {
92662   unsigned long jresult ;
92663   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92664   std::vector< unsigned int >::size_type result;
92665
92666   arg1 = (std::vector< unsigned int > *)jarg1;
92667   {
92668     try {
92669       result = ((std::vector< unsigned int > const *)arg1)->capacity();
92670     } catch (std::out_of_range& e) {
92671       {
92672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92673       };
92674     } catch (std::exception& e) {
92675       {
92676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92677       };
92678     } catch (Dali::DaliException e) {
92679       {
92680         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92681       };
92682     } catch (...) {
92683       {
92684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92685       };
92686     }
92687   }
92688
92689   jresult = (unsigned long)result;
92690   return jresult;
92691 }
92692
92693
92694 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_reserve(void * jarg1, unsigned long jarg2) {
92695   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92696   std::vector< unsigned int >::size_type arg2 ;
92697
92698   arg1 = (std::vector< unsigned int > *)jarg1;
92699   arg2 = (std::vector< unsigned int >::size_type)jarg2;
92700   {
92701     try {
92702       (arg1)->reserve(arg2);
92703     } catch (std::out_of_range& e) {
92704       {
92705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92706       };
92707     } catch (std::exception& e) {
92708       {
92709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92710       };
92711     } catch (Dali::DaliException e) {
92712       {
92713         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92714       };
92715     } catch (...) {
92716       {
92717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92718       };
92719     }
92720   }
92721
92722 }
92723
92724
92725 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_0() {
92726   void * jresult ;
92727   std::vector< unsigned int > *result = 0 ;
92728
92729   {
92730     try {
92731       result = (std::vector< unsigned int > *)new std::vector< unsigned int >();
92732     } catch (std::out_of_range& e) {
92733       {
92734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92735       };
92736     } catch (std::exception& e) {
92737       {
92738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92739       };
92740     } catch (Dali::DaliException e) {
92741       {
92742         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92743       };
92744     } catch (...) {
92745       {
92746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92747       };
92748     }
92749   }
92750
92751   jresult = (void *)result;
92752   return jresult;
92753 }
92754
92755
92756 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_1(void * jarg1) {
92757   void * jresult ;
92758   std::vector< unsigned int > *arg1 = 0 ;
92759   std::vector< unsigned int > *result = 0 ;
92760
92761   arg1 = (std::vector< unsigned int > *)jarg1;
92762   if (!arg1) {
92763     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
92764     return 0;
92765   }
92766   {
92767     try {
92768       result = (std::vector< unsigned int > *)new std::vector< unsigned int >((std::vector< unsigned int > const &)*arg1);
92769     } catch (std::out_of_range& e) {
92770       {
92771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92772       };
92773     } catch (std::exception& e) {
92774       {
92775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92776       };
92777     } catch (Dali::DaliException e) {
92778       {
92779         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92780       };
92781     } catch (...) {
92782       {
92783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92784       };
92785     }
92786   }
92787
92788   jresult = (void *)result;
92789   return jresult;
92790 }
92791
92792
92793 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_2(int jarg1) {
92794   void * jresult ;
92795   int arg1 ;
92796   std::vector< unsigned int > *result = 0 ;
92797
92798   arg1 = (int)jarg1;
92799   {
92800     try {
92801       try {
92802         result = (std::vector< unsigned int > *)new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(arg1);
92803       }
92804       catch(std::out_of_range &_e) {
92805         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92806         return 0;
92807       }
92808
92809     } catch (std::out_of_range& e) {
92810       {
92811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92812       };
92813     } catch (std::exception& e) {
92814       {
92815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92816       };
92817     } catch (Dali::DaliException e) {
92818       {
92819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92820       };
92821     } catch (...) {
92822       {
92823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92824       };
92825     }
92826   }
92827
92828   jresult = (void *)result;
92829   return jresult;
92830 }
92831
92832
92833 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitemcopy(void * jarg1, int jarg2) {
92834   unsigned int jresult ;
92835   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92836   int arg2 ;
92837   unsigned int result;
92838
92839   arg1 = (std::vector< unsigned int > *)jarg1;
92840   arg2 = (int)jarg2;
92841   {
92842     try {
92843       try {
92844         result = (unsigned int)std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(arg1,arg2);
92845       }
92846       catch(std::out_of_range &_e) {
92847         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92848         return 0;
92849       }
92850
92851     } catch (std::out_of_range& e) {
92852       {
92853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92854       };
92855     } catch (std::exception& e) {
92856       {
92857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92858       };
92859     } catch (Dali::DaliException e) {
92860       {
92861         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92862       };
92863     } catch (...) {
92864       {
92865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92866       };
92867     }
92868   }
92869
92870   jresult = result;
92871   return jresult;
92872 }
92873
92874
92875 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitem(void * jarg1, int jarg2) {
92876   unsigned int jresult ;
92877   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92878   int arg2 ;
92879   unsigned int *result = 0 ;
92880
92881   arg1 = (std::vector< unsigned int > *)jarg1;
92882   arg2 = (int)jarg2;
92883   {
92884     try {
92885       try {
92886         result = (unsigned int *) &std_vector_Sl_unsigned_SS_int_Sg__getitem(arg1,arg2);
92887       }
92888       catch(std::out_of_range &_e) {
92889         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92890         return 0;
92891       }
92892
92893     } catch (std::out_of_range& e) {
92894       {
92895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92896       };
92897     } catch (std::exception& e) {
92898       {
92899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92900       };
92901     } catch (Dali::DaliException e) {
92902       {
92903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92904       };
92905     } catch (...) {
92906       {
92907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92908       };
92909     }
92910   }
92911
92912   jresult = *result;
92913   return jresult;
92914 }
92915
92916
92917 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_setitem(void * jarg1, int jarg2, unsigned int jarg3) {
92918   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92919   int arg2 ;
92920   unsigned int *arg3 = 0 ;
92921   unsigned int temp3 ;
92922
92923   arg1 = (std::vector< unsigned int > *)jarg1;
92924   arg2 = (int)jarg2;
92925   temp3 = (unsigned int)jarg3;
92926   arg3 = &temp3;
92927   {
92928     try {
92929       try {
92930         std_vector_Sl_unsigned_SS_int_Sg__setitem(arg1,arg2,(unsigned int const &)*arg3);
92931       }
92932       catch(std::out_of_range &_e) {
92933         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92934         return ;
92935       }
92936
92937     } catch (std::out_of_range& e) {
92938       {
92939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92940       };
92941     } catch (std::exception& e) {
92942       {
92943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92944       };
92945     } catch (Dali::DaliException e) {
92946       {
92947         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92948       };
92949     } catch (...) {
92950       {
92951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92952       };
92953     }
92954   }
92955
92956 }
92957
92958
92959 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_AddRange(void * jarg1, void * jarg2) {
92960   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92961   std::vector< unsigned int > *arg2 = 0 ;
92962
92963   arg1 = (std::vector< unsigned int > *)jarg1;
92964   arg2 = (std::vector< unsigned int > *)jarg2;
92965   if (!arg2) {
92966     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
92967     return ;
92968   }
92969   {
92970     try {
92971       std_vector_Sl_unsigned_SS_int_Sg__AddRange(arg1,(std::vector< unsigned int > const &)*arg2);
92972     } catch (std::out_of_range& e) {
92973       {
92974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92975       };
92976     } catch (std::exception& e) {
92977       {
92978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92979       };
92980     } catch (Dali::DaliException e) {
92981       {
92982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92983       };
92984     } catch (...) {
92985       {
92986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92987       };
92988     }
92989   }
92990
92991 }
92992
92993
92994 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
92995   void * jresult ;
92996   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92997   int arg2 ;
92998   int arg3 ;
92999   std::vector< unsigned int > *result = 0 ;
93000
93001   arg1 = (std::vector< unsigned int > *)jarg1;
93002   arg2 = (int)jarg2;
93003   arg3 = (int)jarg3;
93004   {
93005     try {
93006       try {
93007         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__GetRange(arg1,arg2,arg3);
93008       }
93009       catch(std::out_of_range &_e) {
93010         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93011         return 0;
93012       }
93013       catch(std::invalid_argument &_e) {
93014         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
93015         return 0;
93016       }
93017
93018     } catch (std::out_of_range& e) {
93019       {
93020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93021       };
93022     } catch (std::exception& e) {
93023       {
93024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93025       };
93026     } catch (Dali::DaliException e) {
93027       {
93028         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93029       };
93030     } catch (...) {
93031       {
93032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93033       };
93034     }
93035   }
93036
93037   jresult = (void *)result;
93038   return jresult;
93039 }
93040
93041
93042 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Insert(void * jarg1, int jarg2, unsigned int jarg3) {
93043   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93044   int arg2 ;
93045   unsigned int *arg3 = 0 ;
93046   unsigned int temp3 ;
93047
93048   arg1 = (std::vector< unsigned int > *)jarg1;
93049   arg2 = (int)jarg2;
93050   temp3 = (unsigned int)jarg3;
93051   arg3 = &temp3;
93052   {
93053     try {
93054       try {
93055         std_vector_Sl_unsigned_SS_int_Sg__Insert(arg1,arg2,(unsigned int const &)*arg3);
93056       }
93057       catch(std::out_of_range &_e) {
93058         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93059         return ;
93060       }
93061
93062     } catch (std::out_of_range& e) {
93063       {
93064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93065       };
93066     } catch (std::exception& e) {
93067       {
93068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93069       };
93070     } catch (Dali::DaliException e) {
93071       {
93072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93073       };
93074     } catch (...) {
93075       {
93076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93077       };
93078     }
93079   }
93080
93081 }
93082
93083
93084 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
93085   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93086   int arg2 ;
93087   std::vector< unsigned int > *arg3 = 0 ;
93088
93089   arg1 = (std::vector< unsigned int > *)jarg1;
93090   arg2 = (int)jarg2;
93091   arg3 = (std::vector< unsigned int > *)jarg3;
93092   if (!arg3) {
93093     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
93094     return ;
93095   }
93096   {
93097     try {
93098       try {
93099         std_vector_Sl_unsigned_SS_int_Sg__InsertRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
93100       }
93101       catch(std::out_of_range &_e) {
93102         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93103         return ;
93104       }
93105
93106     } catch (std::out_of_range& e) {
93107       {
93108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93109       };
93110     } catch (std::exception& e) {
93111       {
93112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93113       };
93114     } catch (Dali::DaliException e) {
93115       {
93116         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93117       };
93118     } catch (...) {
93119       {
93120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93121       };
93122     }
93123   }
93124
93125 }
93126
93127
93128 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveAt(void * jarg1, int jarg2) {
93129   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93130   int arg2 ;
93131
93132   arg1 = (std::vector< unsigned int > *)jarg1;
93133   arg2 = (int)jarg2;
93134   {
93135     try {
93136       try {
93137         std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(arg1,arg2);
93138       }
93139       catch(std::out_of_range &_e) {
93140         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93141         return ;
93142       }
93143
93144     } catch (std::out_of_range& e) {
93145       {
93146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93147       };
93148     } catch (std::exception& e) {
93149       {
93150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93151       };
93152     } catch (Dali::DaliException e) {
93153       {
93154         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93155       };
93156     } catch (...) {
93157       {
93158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93159       };
93160     }
93161   }
93162
93163 }
93164
93165
93166 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
93167   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93168   int arg2 ;
93169   int arg3 ;
93170
93171   arg1 = (std::vector< unsigned int > *)jarg1;
93172   arg2 = (int)jarg2;
93173   arg3 = (int)jarg3;
93174   {
93175     try {
93176       try {
93177         std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(arg1,arg2,arg3);
93178       }
93179       catch(std::out_of_range &_e) {
93180         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93181         return ;
93182       }
93183       catch(std::invalid_argument &_e) {
93184         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
93185         return ;
93186       }
93187
93188     } catch (std::out_of_range& e) {
93189       {
93190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93191       };
93192     } catch (std::exception& e) {
93193       {
93194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93195       };
93196     } catch (Dali::DaliException e) {
93197       {
93198         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93199       };
93200     } catch (...) {
93201       {
93202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93203       };
93204     }
93205   }
93206
93207 }
93208
93209
93210 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_Repeat(unsigned int jarg1, int jarg2) {
93211   void * jresult ;
93212   unsigned int *arg1 = 0 ;
93213   int arg2 ;
93214   unsigned int temp1 ;
93215   std::vector< unsigned int > *result = 0 ;
93216
93217   temp1 = (unsigned int)jarg1;
93218   arg1 = &temp1;
93219   arg2 = (int)jarg2;
93220   {
93221     try {
93222       try {
93223         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__Repeat((unsigned int const &)*arg1,arg2);
93224       }
93225       catch(std::out_of_range &_e) {
93226         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93227         return 0;
93228       }
93229
93230     } catch (std::out_of_range& e) {
93231       {
93232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93233       };
93234     } catch (std::exception& e) {
93235       {
93236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93237       };
93238     } catch (Dali::DaliException e) {
93239       {
93240         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93241       };
93242     } catch (...) {
93243       {
93244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93245       };
93246     }
93247   }
93248
93249   jresult = (void *)result;
93250   return jresult;
93251 }
93252
93253
93254 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_0(void * jarg1) {
93255   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93256
93257   arg1 = (std::vector< unsigned int > *)jarg1;
93258   {
93259     try {
93260       std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(arg1);
93261     } catch (std::out_of_range& e) {
93262       {
93263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93264       };
93265     } catch (std::exception& e) {
93266       {
93267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93268       };
93269     } catch (Dali::DaliException e) {
93270       {
93271         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93272       };
93273     } catch (...) {
93274       {
93275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93276       };
93277     }
93278   }
93279
93280 }
93281
93282
93283 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
93284   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93285   int arg2 ;
93286   int arg3 ;
93287
93288   arg1 = (std::vector< unsigned int > *)jarg1;
93289   arg2 = (int)jarg2;
93290   arg3 = (int)jarg3;
93291   {
93292     try {
93293       try {
93294         std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
93295       }
93296       catch(std::out_of_range &_e) {
93297         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93298         return ;
93299       }
93300       catch(std::invalid_argument &_e) {
93301         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
93302         return ;
93303       }
93304
93305     } catch (std::out_of_range& e) {
93306       {
93307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93308       };
93309     } catch (std::exception& e) {
93310       {
93311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93312       };
93313     } catch (Dali::DaliException e) {
93314       {
93315         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93316       };
93317     } catch (...) {
93318       {
93319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93320       };
93321     }
93322   }
93323
93324 }
93325
93326
93327 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
93328   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93329   int arg2 ;
93330   std::vector< unsigned int > *arg3 = 0 ;
93331
93332   arg1 = (std::vector< unsigned int > *)jarg1;
93333   arg2 = (int)jarg2;
93334   arg3 = (std::vector< unsigned int > *)jarg3;
93335   if (!arg3) {
93336     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
93337     return ;
93338   }
93339   {
93340     try {
93341       try {
93342         std_vector_Sl_unsigned_SS_int_Sg__SetRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
93343       }
93344       catch(std::out_of_range &_e) {
93345         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93346         return ;
93347       }
93348
93349     } catch (std::out_of_range& e) {
93350       {
93351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93352       };
93353     } catch (std::exception& e) {
93354       {
93355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93356       };
93357     } catch (Dali::DaliException e) {
93358       {
93359         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93360       };
93361     } catch (...) {
93362       {
93363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93364       };
93365     }
93366   }
93367
93368 }
93369
93370
93371 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Contains(void * jarg1, unsigned int jarg2) {
93372   unsigned int jresult ;
93373   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93374   unsigned int *arg2 = 0 ;
93375   unsigned int temp2 ;
93376   bool result;
93377
93378   arg1 = (std::vector< unsigned int > *)jarg1;
93379   temp2 = (unsigned int)jarg2;
93380   arg2 = &temp2;
93381   {
93382     try {
93383       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Contains(arg1,(unsigned int const &)*arg2);
93384     } catch (std::out_of_range& e) {
93385       {
93386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93387       };
93388     } catch (std::exception& e) {
93389       {
93390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93391       };
93392     } catch (Dali::DaliException e) {
93393       {
93394         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93395       };
93396     } catch (...) {
93397       {
93398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93399       };
93400     }
93401   }
93402
93403   jresult = result;
93404   return jresult;
93405 }
93406
93407
93408 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_IndexOf(void * jarg1, unsigned int jarg2) {
93409   int jresult ;
93410   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93411   unsigned int *arg2 = 0 ;
93412   unsigned int temp2 ;
93413   int result;
93414
93415   arg1 = (std::vector< unsigned int > *)jarg1;
93416   temp2 = (unsigned int)jarg2;
93417   arg2 = &temp2;
93418   {
93419     try {
93420       result = (int)std_vector_Sl_unsigned_SS_int_Sg__IndexOf(arg1,(unsigned int const &)*arg2);
93421     } catch (std::out_of_range& e) {
93422       {
93423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93424       };
93425     } catch (std::exception& e) {
93426       {
93427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93428       };
93429     } catch (Dali::DaliException e) {
93430       {
93431         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93432       };
93433     } catch (...) {
93434       {
93435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93436       };
93437     }
93438   }
93439
93440   jresult = result;
93441   return jresult;
93442 }
93443
93444
93445 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_LastIndexOf(void * jarg1, unsigned int jarg2) {
93446   int jresult ;
93447   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93448   unsigned int *arg2 = 0 ;
93449   unsigned int temp2 ;
93450   int result;
93451
93452   arg1 = (std::vector< unsigned int > *)jarg1;
93453   temp2 = (unsigned int)jarg2;
93454   arg2 = &temp2;
93455   {
93456     try {
93457       result = (int)std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(arg1,(unsigned int const &)*arg2);
93458     } catch (std::out_of_range& e) {
93459       {
93460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93461       };
93462     } catch (std::exception& e) {
93463       {
93464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93465       };
93466     } catch (Dali::DaliException e) {
93467       {
93468         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93469       };
93470     } catch (...) {
93471       {
93472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93473       };
93474     }
93475   }
93476
93477   jresult = result;
93478   return jresult;
93479 }
93480
93481
93482 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Remove(void * jarg1, unsigned int jarg2) {
93483   unsigned int jresult ;
93484   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93485   unsigned int *arg2 = 0 ;
93486   unsigned int temp2 ;
93487   bool result;
93488
93489   arg1 = (std::vector< unsigned int > *)jarg1;
93490   temp2 = (unsigned int)jarg2;
93491   arg2 = &temp2;
93492   {
93493     try {
93494       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Remove(arg1,(unsigned int const &)*arg2);
93495     } catch (std::out_of_range& e) {
93496       {
93497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93498       };
93499     } catch (std::exception& e) {
93500       {
93501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93502       };
93503     } catch (Dali::DaliException e) {
93504       {
93505         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93506       };
93507     } catch (...) {
93508       {
93509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93510       };
93511     }
93512   }
93513
93514   jresult = result;
93515   return jresult;
93516 }
93517
93518
93519 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemIdContainer(void * jarg1) {
93520   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93521
93522   arg1 = (std::vector< unsigned int > *)jarg1;
93523   {
93524     try {
93525       delete arg1;
93526     } catch (std::out_of_range& e) {
93527       {
93528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93529       };
93530     } catch (std::exception& e) {
93531       {
93532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93533       };
93534     } catch (Dali::DaliException e) {
93535       {
93536         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93537       };
93538     } catch (...) {
93539       {
93540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93541       };
93542     }
93543   }
93544
93545 }
93546
93547
93548 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_0() {
93549   void * jresult ;
93550   std::pair< unsigned int,Dali::Actor > *result = 0 ;
93551
93552   {
93553     try {
93554       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >();
93555     } catch (std::out_of_range& e) {
93556       {
93557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93558       };
93559     } catch (std::exception& e) {
93560       {
93561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93562       };
93563     } catch (Dali::DaliException e) {
93564       {
93565         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93566       };
93567     } catch (...) {
93568       {
93569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93570       };
93571     }
93572   }
93573
93574   jresult = (void *)result;
93575   return jresult;
93576 }
93577
93578
93579 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_1(unsigned int jarg1, void * jarg2) {
93580   void * jresult ;
93581   unsigned int arg1 ;
93582   Dali::Actor arg2 ;
93583   Dali::Actor *argp2 ;
93584   std::pair< unsigned int,Dali::Actor > *result = 0 ;
93585
93586   arg1 = (unsigned int)jarg1;
93587   argp2 = (Dali::Actor *)jarg2;
93588   if (!argp2) {
93589     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
93590     return 0;
93591   }
93592   arg2 = *argp2;
93593   {
93594     try {
93595       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >(arg1,arg2);
93596     } catch (std::out_of_range& e) {
93597       {
93598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93599       };
93600     } catch (std::exception& e) {
93601       {
93602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93603       };
93604     } catch (Dali::DaliException e) {
93605       {
93606         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93607       };
93608     } catch (...) {
93609       {
93610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93611       };
93612     }
93613   }
93614
93615   jresult = (void *)result;
93616   return jresult;
93617 }
93618
93619
93620 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_2(void * jarg1) {
93621   void * jresult ;
93622   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
93623   std::pair< unsigned int,Dali::Actor > *result = 0 ;
93624
93625   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93626   if (!arg1) {
93627     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
93628     return 0;
93629   }
93630   {
93631     try {
93632       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >((std::pair< unsigned int,Dali::Actor > const &)*arg1);
93633     } catch (std::out_of_range& e) {
93634       {
93635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93636       };
93637     } catch (std::exception& e) {
93638       {
93639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93640       };
93641     } catch (Dali::DaliException e) {
93642       {
93643         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93644       };
93645     } catch (...) {
93646       {
93647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93648       };
93649     }
93650   }
93651
93652   jresult = (void *)result;
93653   return jresult;
93654 }
93655
93656
93657 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_first_set(void * jarg1, unsigned int jarg2) {
93658   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
93659   unsigned int arg2 ;
93660
93661   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93662   arg2 = (unsigned int)jarg2;
93663   if (arg1) (arg1)->first = arg2;
93664 }
93665
93666
93667 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Item_first_get(void * jarg1) {
93668   unsigned int jresult ;
93669   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
93670   unsigned int result;
93671
93672   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93673   result = (unsigned int) ((arg1)->first);
93674   jresult = result;
93675   return jresult;
93676 }
93677
93678
93679 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_second_set(void * jarg1, void * jarg2) {
93680   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
93681   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
93682
93683   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93684   arg2 = (Dali::Actor *)jarg2;
93685   if (arg1) (arg1)->second = *arg2;
93686 }
93687
93688
93689 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Item_second_get(void * jarg1) {
93690   void * jresult ;
93691   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
93692   Dali::Actor *result = 0 ;
93693
93694   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93695   result = (Dali::Actor *)& ((arg1)->second);
93696   jresult = (void *)result;
93697   return jresult;
93698 }
93699
93700
93701 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Item(void * jarg1) {
93702   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
93703
93704   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93705   {
93706     try {
93707       delete arg1;
93708     } catch (std::out_of_range& e) {
93709       {
93710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93711       };
93712     } catch (std::exception& e) {
93713       {
93714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93715       };
93716     } catch (Dali::DaliException e) {
93717       {
93718         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93719       };
93720     } catch (...) {
93721       {
93722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93723       };
93724     }
93725   }
93726
93727 }
93728
93729
93730 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Clear(void * jarg1) {
93731   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93732
93733   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93734   {
93735     try {
93736       (arg1)->clear();
93737     } catch (std::out_of_range& e) {
93738       {
93739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93740       };
93741     } catch (std::exception& e) {
93742       {
93743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93744       };
93745     } catch (Dali::DaliException e) {
93746       {
93747         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93748       };
93749     } catch (...) {
93750       {
93751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93752       };
93753     }
93754   }
93755
93756 }
93757
93758
93759 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Add(void * jarg1, void * jarg2) {
93760   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93761   std::pair< unsigned int,Dali::Actor > *arg2 = 0 ;
93762
93763   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93764   arg2 = (std::pair< unsigned int,Dali::Actor > *)jarg2;
93765   if (!arg2) {
93766     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
93767     return ;
93768   }
93769   {
93770     try {
93771       (arg1)->push_back((std::pair< unsigned int,Dali::Actor > const &)*arg2);
93772     } catch (std::out_of_range& e) {
93773       {
93774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93775       };
93776     } catch (std::exception& e) {
93777       {
93778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93779       };
93780     } catch (Dali::DaliException e) {
93781       {
93782         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93783       };
93784     } catch (...) {
93785       {
93786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93787       };
93788     }
93789   }
93790
93791 }
93792
93793
93794 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_size(void * jarg1) {
93795   unsigned long jresult ;
93796   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93797   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
93798
93799   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93800   {
93801     try {
93802       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->size();
93803     } catch (std::out_of_range& e) {
93804       {
93805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93806       };
93807     } catch (std::exception& e) {
93808       {
93809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93810       };
93811     } catch (Dali::DaliException e) {
93812       {
93813         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93814       };
93815     } catch (...) {
93816       {
93817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93818       };
93819     }
93820   }
93821
93822   jresult = (unsigned long)result;
93823   return jresult;
93824 }
93825
93826
93827 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_capacity(void * jarg1) {
93828   unsigned long jresult ;
93829   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93830   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
93831
93832   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93833   {
93834     try {
93835       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->capacity();
93836     } catch (std::out_of_range& e) {
93837       {
93838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93839       };
93840     } catch (std::exception& e) {
93841       {
93842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93843       };
93844     } catch (Dali::DaliException e) {
93845       {
93846         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93847       };
93848     } catch (...) {
93849       {
93850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93851       };
93852     }
93853   }
93854
93855   jresult = (unsigned long)result;
93856   return jresult;
93857 }
93858
93859
93860 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_reserve(void * jarg1, unsigned long jarg2) {
93861   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93862   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type arg2 ;
93863
93864   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93865   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > >::size_type)jarg2;
93866   {
93867     try {
93868       (arg1)->reserve(arg2);
93869     } catch (std::out_of_range& e) {
93870       {
93871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93872       };
93873     } catch (std::exception& e) {
93874       {
93875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93876       };
93877     } catch (Dali::DaliException e) {
93878       {
93879         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93880       };
93881     } catch (...) {
93882       {
93883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93884       };
93885     }
93886   }
93887
93888 }
93889
93890
93891 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_0() {
93892   void * jresult ;
93893   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
93894
93895   {
93896     try {
93897       result = (std::vector< std::pair< unsigned int,Dali::Actor > > *)new std::vector< std::pair< unsigned int,Dali::Actor > >();
93898     } catch (std::out_of_range& e) {
93899       {
93900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93901       };
93902     } catch (std::exception& e) {
93903       {
93904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93905       };
93906     } catch (Dali::DaliException e) {
93907       {
93908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93909       };
93910     } catch (...) {
93911       {
93912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93913       };
93914     }
93915   }
93916
93917   jresult = (void *)result;
93918   return jresult;
93919 }
93920
93921
93922 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_1(void * jarg1) {
93923   void * jresult ;
93924   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = 0 ;
93925   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
93926
93927   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93928   if (!arg1) {
93929     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
93930     return 0;
93931   }
93932   {
93933     try {
93934       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);
93935     } catch (std::out_of_range& e) {
93936       {
93937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93938       };
93939     } catch (std::exception& e) {
93940       {
93941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93942       };
93943     } catch (Dali::DaliException e) {
93944       {
93945         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93946       };
93947     } catch (...) {
93948       {
93949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93950       };
93951     }
93952   }
93953
93954   jresult = (void *)result;
93955   return jresult;
93956 }
93957
93958
93959 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_2(int jarg1) {
93960   void * jresult ;
93961   int arg1 ;
93962   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
93963
93964   arg1 = (int)jarg1;
93965   {
93966     try {
93967       try {
93968         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);
93969       }
93970       catch(std::out_of_range &_e) {
93971         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93972         return 0;
93973       }
93974
93975     } catch (std::out_of_range& e) {
93976       {
93977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93978       };
93979     } catch (std::exception& e) {
93980       {
93981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93982       };
93983     } catch (Dali::DaliException e) {
93984       {
93985         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93986       };
93987     } catch (...) {
93988       {
93989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93990       };
93991     }
93992   }
93993
93994   jresult = (void *)result;
93995   return jresult;
93996 }
93997
93998
93999 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitemcopy(void * jarg1, int jarg2) {
94000   void * jresult ;
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 > result;
94004
94005   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94006   arg2 = (int)jarg2;
94007   {
94008     try {
94009       try {
94010         result = std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitemcopy(arg1,arg2);
94011       }
94012       catch(std::out_of_range &_e) {
94013         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94014         return 0;
94015       }
94016
94017     } catch (std::out_of_range& e) {
94018       {
94019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94020       };
94021     } catch (std::exception& e) {
94022       {
94023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94024       };
94025     } catch (Dali::DaliException e) {
94026       {
94027         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94028       };
94029     } catch (...) {
94030       {
94031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94032       };
94033     }
94034   }
94035
94036   jresult = new std::pair< unsigned int,Dali::Actor >((const std::pair< unsigned int,Dali::Actor > &)result);
94037   return jresult;
94038 }
94039
94040
94041 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitem(void * jarg1, int jarg2) {
94042   void * jresult ;
94043   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94044   int arg2 ;
94045   std::pair< unsigned int,Dali::Actor > *result = 0 ;
94046
94047   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94048   arg2 = (int)jarg2;
94049   {
94050     try {
94051       try {
94052         result = (std::pair< unsigned int,Dali::Actor > *) &std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitem(arg1,arg2);
94053       }
94054       catch(std::out_of_range &_e) {
94055         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94056         return 0;
94057       }
94058
94059     } catch (std::out_of_range& e) {
94060       {
94061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94062       };
94063     } catch (std::exception& e) {
94064       {
94065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94066       };
94067     } catch (Dali::DaliException e) {
94068       {
94069         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94070       };
94071     } catch (...) {
94072       {
94073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94074       };
94075     }
94076   }
94077
94078   jresult = (void *)result;
94079   return jresult;
94080 }
94081
94082
94083 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
94084   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94085   int arg2 ;
94086   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
94087
94088   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94089   arg2 = (int)jarg2;
94090   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
94091   if (!arg3) {
94092     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
94093     return ;
94094   }
94095   {
94096     try {
94097       try {
94098         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);
94099       }
94100       catch(std::out_of_range &_e) {
94101         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94102         return ;
94103       }
94104
94105     } catch (std::out_of_range& e) {
94106       {
94107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94108       };
94109     } catch (std::exception& e) {
94110       {
94111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94112       };
94113     } catch (Dali::DaliException e) {
94114       {
94115         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94116       };
94117     } catch (...) {
94118       {
94119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94120       };
94121     }
94122   }
94123
94124 }
94125
94126
94127 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_AddRange(void * jarg1, void * jarg2) {
94128   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94129   std::vector< std::pair< unsigned int,Dali::Actor > > *arg2 = 0 ;
94130
94131   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94132   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg2;
94133   if (!arg2) {
94134     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
94135     return ;
94136   }
94137   {
94138     try {
94139       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);
94140     } catch (std::out_of_range& e) {
94141       {
94142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94143       };
94144     } catch (std::exception& e) {
94145       {
94146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94147       };
94148     } catch (Dali::DaliException e) {
94149       {
94150         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94151       };
94152     } catch (...) {
94153       {
94154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94155       };
94156     }
94157   }
94158
94159 }
94160
94161
94162 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
94163   void * jresult ;
94164   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94165   int arg2 ;
94166   int arg3 ;
94167   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
94168
94169   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94170   arg2 = (int)jarg2;
94171   arg3 = (int)jarg3;
94172   {
94173     try {
94174       try {
94175         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);
94176       }
94177       catch(std::out_of_range &_e) {
94178         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94179         return 0;
94180       }
94181       catch(std::invalid_argument &_e) {
94182         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
94183         return 0;
94184       }
94185
94186     } catch (std::out_of_range& e) {
94187       {
94188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94189       };
94190     } catch (std::exception& e) {
94191       {
94192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94193       };
94194     } catch (Dali::DaliException e) {
94195       {
94196         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94197       };
94198     } catch (...) {
94199       {
94200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94201       };
94202     }
94203   }
94204
94205   jresult = (void *)result;
94206   return jresult;
94207 }
94208
94209
94210 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
94211   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94212   int arg2 ;
94213   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
94214
94215   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94216   arg2 = (int)jarg2;
94217   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
94218   if (!arg3) {
94219     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
94220     return ;
94221   }
94222   {
94223     try {
94224       try {
94225         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);
94226       }
94227       catch(std::out_of_range &_e) {
94228         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94229         return ;
94230       }
94231
94232     } catch (std::out_of_range& e) {
94233       {
94234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94235       };
94236     } catch (std::exception& e) {
94237       {
94238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94239       };
94240     } catch (Dali::DaliException e) {
94241       {
94242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94243       };
94244     } catch (...) {
94245       {
94246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94247       };
94248     }
94249   }
94250
94251 }
94252
94253
94254 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
94255   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94256   int arg2 ;
94257   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
94258
94259   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94260   arg2 = (int)jarg2;
94261   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
94262   if (!arg3) {
94263     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
94264     return ;
94265   }
94266   {
94267     try {
94268       try {
94269         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);
94270       }
94271       catch(std::out_of_range &_e) {
94272         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94273         return ;
94274       }
94275
94276     } catch (std::out_of_range& e) {
94277       {
94278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94279       };
94280     } catch (std::exception& e) {
94281       {
94282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94283       };
94284     } catch (Dali::DaliException e) {
94285       {
94286         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94287       };
94288     } catch (...) {
94289       {
94290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94291       };
94292     }
94293   }
94294
94295 }
94296
94297
94298 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveAt(void * jarg1, int jarg2) {
94299   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94300   int arg2 ;
94301
94302   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94303   arg2 = (int)jarg2;
94304   {
94305     try {
94306       try {
94307         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveAt(arg1,arg2);
94308       }
94309       catch(std::out_of_range &_e) {
94310         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94311         return ;
94312       }
94313
94314     } catch (std::out_of_range& e) {
94315       {
94316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94317       };
94318     } catch (std::exception& e) {
94319       {
94320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94321       };
94322     } catch (Dali::DaliException e) {
94323       {
94324         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94325       };
94326     } catch (...) {
94327       {
94328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94329       };
94330     }
94331   }
94332
94333 }
94334
94335
94336 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
94337   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94338   int arg2 ;
94339   int arg3 ;
94340
94341   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94342   arg2 = (int)jarg2;
94343   arg3 = (int)jarg3;
94344   {
94345     try {
94346       try {
94347         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveRange(arg1,arg2,arg3);
94348       }
94349       catch(std::out_of_range &_e) {
94350         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94351         return ;
94352       }
94353       catch(std::invalid_argument &_e) {
94354         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
94355         return ;
94356       }
94357
94358     } catch (std::out_of_range& e) {
94359       {
94360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94361       };
94362     } catch (std::exception& e) {
94363       {
94364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94365       };
94366     } catch (Dali::DaliException e) {
94367       {
94368         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94369       };
94370     } catch (...) {
94371       {
94372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94373       };
94374     }
94375   }
94376
94377 }
94378
94379
94380 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_Repeat(void * jarg1, int jarg2) {
94381   void * jresult ;
94382   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
94383   int arg2 ;
94384   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
94385
94386   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
94387   if (!arg1) {
94388     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
94389     return 0;
94390   }
94391   arg2 = (int)jarg2;
94392   {
94393     try {
94394       try {
94395         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);
94396       }
94397       catch(std::out_of_range &_e) {
94398         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94399         return 0;
94400       }
94401
94402     } catch (std::out_of_range& e) {
94403       {
94404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94405       };
94406     } catch (std::exception& e) {
94407       {
94408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94409       };
94410     } catch (Dali::DaliException e) {
94411       {
94412         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94413       };
94414     } catch (...) {
94415       {
94416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94417       };
94418     }
94419   }
94420
94421   jresult = (void *)result;
94422   return jresult;
94423 }
94424
94425
94426 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_0(void * jarg1) {
94427   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94428
94429   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94430   {
94431     try {
94432       std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_0(arg1);
94433     } catch (std::out_of_range& e) {
94434       {
94435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94436       };
94437     } catch (std::exception& e) {
94438       {
94439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94440       };
94441     } catch (Dali::DaliException e) {
94442       {
94443         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94444       };
94445     } catch (...) {
94446       {
94447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94448       };
94449     }
94450   }
94451
94452 }
94453
94454
94455 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
94456   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94457   int arg2 ;
94458   int arg3 ;
94459
94460   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94461   arg2 = (int)jarg2;
94462   arg3 = (int)jarg3;
94463   {
94464     try {
94465       try {
94466         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
94467       }
94468       catch(std::out_of_range &_e) {
94469         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94470         return ;
94471       }
94472       catch(std::invalid_argument &_e) {
94473         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
94474         return ;
94475       }
94476
94477     } catch (std::out_of_range& e) {
94478       {
94479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94480       };
94481     } catch (std::exception& e) {
94482       {
94483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94484       };
94485     } catch (Dali::DaliException e) {
94486       {
94487         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94488       };
94489     } catch (...) {
94490       {
94491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94492       };
94493     }
94494   }
94495
94496 }
94497
94498
94499 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
94500   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94501   int arg2 ;
94502   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
94503
94504   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94505   arg2 = (int)jarg2;
94506   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
94507   if (!arg3) {
94508     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
94509     return ;
94510   }
94511   {
94512     try {
94513       try {
94514         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);
94515       }
94516       catch(std::out_of_range &_e) {
94517         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94518         return ;
94519       }
94520
94521     } catch (std::out_of_range& e) {
94522       {
94523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94524       };
94525     } catch (std::exception& e) {
94526       {
94527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94528       };
94529     } catch (Dali::DaliException e) {
94530       {
94531         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94532       };
94533     } catch (...) {
94534       {
94535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94536       };
94537     }
94538   }
94539
94540 }
94541
94542
94543 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemContainer(void * jarg1) {
94544   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94545
94546   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94547   {
94548     try {
94549       delete arg1;
94550     } catch (std::out_of_range& e) {
94551       {
94552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94553       };
94554     } catch (std::exception& e) {
94555       {
94556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94557       };
94558     } catch (Dali::DaliException e) {
94559       {
94560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94561       };
94562     } catch (...) {
94563       {
94564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94565       };
94566     }
94567   }
94568
94569 }
94570
94571
94572 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Clear(void * jarg1) {
94573   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94574
94575   arg1 = (std::vector< Dali::Actor > *)jarg1;
94576   {
94577     try {
94578       (arg1)->clear();
94579     } catch (std::out_of_range& e) {
94580       {
94581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94582       };
94583     } catch (std::exception& e) {
94584       {
94585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94586       };
94587     } catch (Dali::DaliException e) {
94588       {
94589         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94590       };
94591     } catch (...) {
94592       {
94593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94594       };
94595     }
94596   }
94597
94598 }
94599
94600
94601 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Add(void * jarg1, void * jarg2) {
94602   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94603   Dali::Actor *arg2 = 0 ;
94604
94605   arg1 = (std::vector< Dali::Actor > *)jarg1;
94606   arg2 = (Dali::Actor *)jarg2;
94607   if (!arg2) {
94608     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
94609     return ;
94610   }
94611   {
94612     try {
94613       (arg1)->push_back((Dali::Actor const &)*arg2);
94614     } catch (std::out_of_range& e) {
94615       {
94616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94617       };
94618     } catch (std::exception& e) {
94619       {
94620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94621       };
94622     } catch (Dali::DaliException e) {
94623       {
94624         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94625       };
94626     } catch (...) {
94627       {
94628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94629       };
94630     }
94631   }
94632
94633 }
94634
94635
94636 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_size(void * jarg1) {
94637   unsigned long jresult ;
94638   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94639   std::vector< Dali::Actor >::size_type result;
94640
94641   arg1 = (std::vector< Dali::Actor > *)jarg1;
94642   {
94643     try {
94644       result = ((std::vector< Dali::Actor > const *)arg1)->size();
94645     } catch (std::out_of_range& e) {
94646       {
94647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94648       };
94649     } catch (std::exception& e) {
94650       {
94651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94652       };
94653     } catch (Dali::DaliException e) {
94654       {
94655         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94656       };
94657     } catch (...) {
94658       {
94659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94660       };
94661     }
94662   }
94663
94664   jresult = (unsigned long)result;
94665   return jresult;
94666 }
94667
94668
94669 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_capacity(void * jarg1) {
94670   unsigned long jresult ;
94671   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94672   std::vector< Dali::Actor >::size_type result;
94673
94674   arg1 = (std::vector< Dali::Actor > *)jarg1;
94675   {
94676     try {
94677       result = ((std::vector< Dali::Actor > const *)arg1)->capacity();
94678     } catch (std::out_of_range& e) {
94679       {
94680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94681       };
94682     } catch (std::exception& e) {
94683       {
94684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94685       };
94686     } catch (Dali::DaliException e) {
94687       {
94688         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94689       };
94690     } catch (...) {
94691       {
94692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94693       };
94694     }
94695   }
94696
94697   jresult = (unsigned long)result;
94698   return jresult;
94699 }
94700
94701
94702 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_reserve(void * jarg1, unsigned long jarg2) {
94703   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94704   std::vector< Dali::Actor >::size_type arg2 ;
94705
94706   arg1 = (std::vector< Dali::Actor > *)jarg1;
94707   arg2 = (std::vector< Dali::Actor >::size_type)jarg2;
94708   {
94709     try {
94710       (arg1)->reserve(arg2);
94711     } catch (std::out_of_range& e) {
94712       {
94713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94714       };
94715     } catch (std::exception& e) {
94716       {
94717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94718       };
94719     } catch (Dali::DaliException e) {
94720       {
94721         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94722       };
94723     } catch (...) {
94724       {
94725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94726       };
94727     }
94728   }
94729
94730 }
94731
94732
94733 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_0() {
94734   void * jresult ;
94735   std::vector< Dali::Actor > *result = 0 ;
94736
94737   {
94738     try {
94739       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >();
94740     } catch (std::out_of_range& e) {
94741       {
94742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94743       };
94744     } catch (std::exception& e) {
94745       {
94746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94747       };
94748     } catch (Dali::DaliException e) {
94749       {
94750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94751       };
94752     } catch (...) {
94753       {
94754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94755       };
94756     }
94757   }
94758
94759   jresult = (void *)result;
94760   return jresult;
94761 }
94762
94763
94764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_1(void * jarg1) {
94765   void * jresult ;
94766   std::vector< Dali::Actor > *arg1 = 0 ;
94767   std::vector< Dali::Actor > *result = 0 ;
94768
94769   arg1 = (std::vector< Dali::Actor > *)jarg1;
94770   if (!arg1) {
94771     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
94772     return 0;
94773   }
94774   {
94775     try {
94776       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >((std::vector< Dali::Actor > const &)*arg1);
94777     } catch (std::out_of_range& e) {
94778       {
94779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94780       };
94781     } catch (std::exception& e) {
94782       {
94783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94784       };
94785     } catch (Dali::DaliException e) {
94786       {
94787         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94788       };
94789     } catch (...) {
94790       {
94791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94792       };
94793     }
94794   }
94795
94796   jresult = (void *)result;
94797   return jresult;
94798 }
94799
94800
94801 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_2(int jarg1) {
94802   void * jresult ;
94803   int arg1 ;
94804   std::vector< Dali::Actor > *result = 0 ;
94805
94806   arg1 = (int)jarg1;
94807   {
94808     try {
94809       try {
94810         result = (std::vector< Dali::Actor > *)new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(arg1);
94811       }
94812       catch(std::out_of_range &_e) {
94813         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94814         return 0;
94815       }
94816
94817     } catch (std::out_of_range& e) {
94818       {
94819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94820       };
94821     } catch (std::exception& e) {
94822       {
94823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94824       };
94825     } catch (Dali::DaliException e) {
94826       {
94827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94828       };
94829     } catch (...) {
94830       {
94831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94832       };
94833     }
94834   }
94835
94836   jresult = (void *)result;
94837   return jresult;
94838 }
94839
94840
94841 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitemcopy(void * jarg1, int jarg2) {
94842   void * jresult ;
94843   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94844   int arg2 ;
94845   Dali::Actor result;
94846
94847   arg1 = (std::vector< Dali::Actor > *)jarg1;
94848   arg2 = (int)jarg2;
94849   {
94850     try {
94851       try {
94852         result = std_vector_Sl_Dali_Actor_Sg__getitemcopy(arg1,arg2);
94853       }
94854       catch(std::out_of_range &_e) {
94855         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94856         return 0;
94857       }
94858
94859     } catch (std::out_of_range& e) {
94860       {
94861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94862       };
94863     } catch (std::exception& e) {
94864       {
94865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94866       };
94867     } catch (Dali::DaliException e) {
94868       {
94869         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94870       };
94871     } catch (...) {
94872       {
94873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94874       };
94875     }
94876   }
94877
94878   jresult = new Dali::Actor((const Dali::Actor &)result);
94879   return jresult;
94880 }
94881
94882
94883 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitem(void * jarg1, int jarg2) {
94884   void * jresult ;
94885   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94886   int arg2 ;
94887   Dali::Actor *result = 0 ;
94888
94889   arg1 = (std::vector< Dali::Actor > *)jarg1;
94890   arg2 = (int)jarg2;
94891   {
94892     try {
94893       try {
94894         result = (Dali::Actor *) &std_vector_Sl_Dali_Actor_Sg__getitem(arg1,arg2);
94895       }
94896       catch(std::out_of_range &_e) {
94897         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94898         return 0;
94899       }
94900
94901     } catch (std::out_of_range& e) {
94902       {
94903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94904       };
94905     } catch (std::exception& e) {
94906       {
94907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94908       };
94909     } catch (Dali::DaliException e) {
94910       {
94911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94912       };
94913     } catch (...) {
94914       {
94915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94916       };
94917     }
94918   }
94919
94920   jresult = (void *)result;
94921   return jresult;
94922 }
94923
94924
94925 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
94926   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94927   int arg2 ;
94928   Dali::Actor *arg3 = 0 ;
94929
94930   arg1 = (std::vector< Dali::Actor > *)jarg1;
94931   arg2 = (int)jarg2;
94932   arg3 = (Dali::Actor *)jarg3;
94933   if (!arg3) {
94934     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
94935     return ;
94936   }
94937   {
94938     try {
94939       try {
94940         std_vector_Sl_Dali_Actor_Sg__setitem(arg1,arg2,(Dali::Actor const &)*arg3);
94941       }
94942       catch(std::out_of_range &_e) {
94943         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94944         return ;
94945       }
94946
94947     } catch (std::out_of_range& e) {
94948       {
94949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94950       };
94951     } catch (std::exception& e) {
94952       {
94953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94954       };
94955     } catch (Dali::DaliException e) {
94956       {
94957         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94958       };
94959     } catch (...) {
94960       {
94961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94962       };
94963     }
94964   }
94965
94966 }
94967
94968
94969 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_AddRange(void * jarg1, void * jarg2) {
94970   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94971   std::vector< Dali::Actor > *arg2 = 0 ;
94972
94973   arg1 = (std::vector< Dali::Actor > *)jarg1;
94974   arg2 = (std::vector< Dali::Actor > *)jarg2;
94975   if (!arg2) {
94976     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
94977     return ;
94978   }
94979   {
94980     try {
94981       std_vector_Sl_Dali_Actor_Sg__AddRange(arg1,(std::vector< Dali::Actor > const &)*arg2);
94982     } catch (std::out_of_range& e) {
94983       {
94984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94985       };
94986     } catch (std::exception& e) {
94987       {
94988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94989       };
94990     } catch (Dali::DaliException e) {
94991       {
94992         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94993       };
94994     } catch (...) {
94995       {
94996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94997       };
94998     }
94999   }
95000
95001 }
95002
95003
95004 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
95005   void * jresult ;
95006   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95007   int arg2 ;
95008   int arg3 ;
95009   std::vector< Dali::Actor > *result = 0 ;
95010
95011   arg1 = (std::vector< Dali::Actor > *)jarg1;
95012   arg2 = (int)jarg2;
95013   arg3 = (int)jarg3;
95014   {
95015     try {
95016       try {
95017         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__GetRange(arg1,arg2,arg3);
95018       }
95019       catch(std::out_of_range &_e) {
95020         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95021         return 0;
95022       }
95023       catch(std::invalid_argument &_e) {
95024         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
95025         return 0;
95026       }
95027
95028     } catch (std::out_of_range& e) {
95029       {
95030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95031       };
95032     } catch (std::exception& e) {
95033       {
95034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95035       };
95036     } catch (Dali::DaliException e) {
95037       {
95038         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95039       };
95040     } catch (...) {
95041       {
95042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95043       };
95044     }
95045   }
95046
95047   jresult = (void *)result;
95048   return jresult;
95049 }
95050
95051
95052 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
95053   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95054   int arg2 ;
95055   Dali::Actor *arg3 = 0 ;
95056
95057   arg1 = (std::vector< Dali::Actor > *)jarg1;
95058   arg2 = (int)jarg2;
95059   arg3 = (Dali::Actor *)jarg3;
95060   if (!arg3) {
95061     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
95062     return ;
95063   }
95064   {
95065     try {
95066       try {
95067         std_vector_Sl_Dali_Actor_Sg__Insert(arg1,arg2,(Dali::Actor const &)*arg3);
95068       }
95069       catch(std::out_of_range &_e) {
95070         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95071         return ;
95072       }
95073
95074     } catch (std::out_of_range& e) {
95075       {
95076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95077       };
95078     } catch (std::exception& e) {
95079       {
95080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95081       };
95082     } catch (Dali::DaliException e) {
95083       {
95084         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95085       };
95086     } catch (...) {
95087       {
95088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95089       };
95090     }
95091   }
95092
95093 }
95094
95095
95096 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
95097   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95098   int arg2 ;
95099   std::vector< Dali::Actor > *arg3 = 0 ;
95100
95101   arg1 = (std::vector< Dali::Actor > *)jarg1;
95102   arg2 = (int)jarg2;
95103   arg3 = (std::vector< Dali::Actor > *)jarg3;
95104   if (!arg3) {
95105     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
95106     return ;
95107   }
95108   {
95109     try {
95110       try {
95111         std_vector_Sl_Dali_Actor_Sg__InsertRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
95112       }
95113       catch(std::out_of_range &_e) {
95114         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95115         return ;
95116       }
95117
95118     } catch (std::out_of_range& e) {
95119       {
95120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95121       };
95122     } catch (std::exception& e) {
95123       {
95124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95125       };
95126     } catch (Dali::DaliException e) {
95127       {
95128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95129       };
95130     } catch (...) {
95131       {
95132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95133       };
95134     }
95135   }
95136
95137 }
95138
95139
95140 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveAt(void * jarg1, int jarg2) {
95141   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95142   int arg2 ;
95143
95144   arg1 = (std::vector< Dali::Actor > *)jarg1;
95145   arg2 = (int)jarg2;
95146   {
95147     try {
95148       try {
95149         std_vector_Sl_Dali_Actor_Sg__RemoveAt(arg1,arg2);
95150       }
95151       catch(std::out_of_range &_e) {
95152         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95153         return ;
95154       }
95155
95156     } catch (std::out_of_range& e) {
95157       {
95158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95159       };
95160     } catch (std::exception& e) {
95161       {
95162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95163       };
95164     } catch (Dali::DaliException e) {
95165       {
95166         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95167       };
95168     } catch (...) {
95169       {
95170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95171       };
95172     }
95173   }
95174
95175 }
95176
95177
95178 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
95179   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95180   int arg2 ;
95181   int arg3 ;
95182
95183   arg1 = (std::vector< Dali::Actor > *)jarg1;
95184   arg2 = (int)jarg2;
95185   arg3 = (int)jarg3;
95186   {
95187     try {
95188       try {
95189         std_vector_Sl_Dali_Actor_Sg__RemoveRange(arg1,arg2,arg3);
95190       }
95191       catch(std::out_of_range &_e) {
95192         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95193         return ;
95194       }
95195       catch(std::invalid_argument &_e) {
95196         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
95197         return ;
95198       }
95199
95200     } catch (std::out_of_range& e) {
95201       {
95202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95203       };
95204     } catch (std::exception& e) {
95205       {
95206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95207       };
95208     } catch (Dali::DaliException e) {
95209       {
95210         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95211       };
95212     } catch (...) {
95213       {
95214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95215       };
95216     }
95217   }
95218
95219 }
95220
95221
95222 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_Repeat(void * jarg1, int jarg2) {
95223   void * jresult ;
95224   Dali::Actor *arg1 = 0 ;
95225   int arg2 ;
95226   std::vector< Dali::Actor > *result = 0 ;
95227
95228   arg1 = (Dali::Actor *)jarg1;
95229   if (!arg1) {
95230     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
95231     return 0;
95232   }
95233   arg2 = (int)jarg2;
95234   {
95235     try {
95236       try {
95237         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__Repeat((Dali::Actor const &)*arg1,arg2);
95238       }
95239       catch(std::out_of_range &_e) {
95240         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95241         return 0;
95242       }
95243
95244     } catch (std::out_of_range& e) {
95245       {
95246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95247       };
95248     } catch (std::exception& e) {
95249       {
95250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95251       };
95252     } catch (Dali::DaliException e) {
95253       {
95254         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95255       };
95256     } catch (...) {
95257       {
95258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95259       };
95260     }
95261   }
95262
95263   jresult = (void *)result;
95264   return jresult;
95265 }
95266
95267
95268 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_0(void * jarg1) {
95269   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95270
95271   arg1 = (std::vector< Dali::Actor > *)jarg1;
95272   {
95273     try {
95274       std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(arg1);
95275     } catch (std::out_of_range& e) {
95276       {
95277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95278       };
95279     } catch (std::exception& e) {
95280       {
95281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95282       };
95283     } catch (Dali::DaliException e) {
95284       {
95285         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95286       };
95287     } catch (...) {
95288       {
95289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95290       };
95291     }
95292   }
95293
95294 }
95295
95296
95297 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
95298   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95299   int arg2 ;
95300   int arg3 ;
95301
95302   arg1 = (std::vector< Dali::Actor > *)jarg1;
95303   arg2 = (int)jarg2;
95304   arg3 = (int)jarg3;
95305   {
95306     try {
95307       try {
95308         std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
95309       }
95310       catch(std::out_of_range &_e) {
95311         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95312         return ;
95313       }
95314       catch(std::invalid_argument &_e) {
95315         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
95316         return ;
95317       }
95318
95319     } catch (std::out_of_range& e) {
95320       {
95321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95322       };
95323     } catch (std::exception& e) {
95324       {
95325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95326       };
95327     } catch (Dali::DaliException e) {
95328       {
95329         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95330       };
95331     } catch (...) {
95332       {
95333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95334       };
95335     }
95336   }
95337
95338 }
95339
95340
95341 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
95342   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95343   int arg2 ;
95344   std::vector< Dali::Actor > *arg3 = 0 ;
95345
95346   arg1 = (std::vector< Dali::Actor > *)jarg1;
95347   arg2 = (int)jarg2;
95348   arg3 = (std::vector< Dali::Actor > *)jarg3;
95349   if (!arg3) {
95350     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
95351     return ;
95352   }
95353   {
95354     try {
95355       try {
95356         std_vector_Sl_Dali_Actor_Sg__SetRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
95357       }
95358       catch(std::out_of_range &_e) {
95359         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95360         return ;
95361       }
95362
95363     } catch (std::out_of_range& e) {
95364       {
95365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95366       };
95367     } catch (std::exception& e) {
95368       {
95369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95370       };
95371     } catch (Dali::DaliException e) {
95372       {
95373         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95374       };
95375     } catch (...) {
95376       {
95377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95378       };
95379     }
95380   }
95381
95382 }
95383
95384
95385 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorContainer(void * jarg1) {
95386   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95387
95388   arg1 = (std::vector< Dali::Actor > *)jarg1;
95389   {
95390     try {
95391       delete arg1;
95392     } catch (std::out_of_range& e) {
95393       {
95394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95395       };
95396     } catch (std::exception& e) {
95397       {
95398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95399       };
95400     } catch (Dali::DaliException e) {
95401       {
95402         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95403       };
95404     } catch (...) {
95405       {
95406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95407       };
95408     }
95409   }
95410
95411 }
95412
95413
95414 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Empty(void * jarg1) {
95415   unsigned int jresult ;
95416   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95417   bool result;
95418
95419   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95420   {
95421     try {
95422       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
95423     } catch (std::out_of_range& e) {
95424       {
95425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95426       };
95427     } catch (std::exception& e) {
95428       {
95429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95430       };
95431     } catch (Dali::DaliException e) {
95432       {
95433         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95434       };
95435     } catch (...) {
95436       {
95437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95438       };
95439     }
95440   }
95441
95442   jresult = result;
95443   return jresult;
95444 }
95445
95446
95447 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_GetConnectionCount(void * jarg1) {
95448   unsigned long jresult ;
95449   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95450   std::size_t result;
95451
95452   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95453   {
95454     try {
95455       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
95456     } catch (std::out_of_range& e) {
95457       {
95458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95459       };
95460     } catch (std::exception& e) {
95461       {
95462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95463       };
95464     } catch (Dali::DaliException e) {
95465       {
95466         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95467       };
95468     } catch (...) {
95469       {
95470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95471       };
95472     }
95473   }
95474
95475   jresult = (unsigned long)result;
95476   return jresult;
95477 }
95478
95479
95480 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Connect(void * jarg1, void * jarg2) {
95481   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95482   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
95483
95484   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95485   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
95486   {
95487     try {
95488       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Connect(arg1,arg2);
95489     } catch (std::out_of_range& e) {
95490       {
95491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95492       };
95493     } catch (std::exception& e) {
95494       {
95495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95496       };
95497     } catch (Dali::DaliException e) {
95498       {
95499         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95500       };
95501     } catch (...) {
95502       {
95503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95504       };
95505     }
95506   }
95507
95508 }
95509
95510
95511 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Disconnect(void * jarg1, void * jarg2) {
95512   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95513   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
95514
95515   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95516   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
95517   {
95518     try {
95519       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Disconnect(arg1,arg2);
95520     } catch (std::out_of_range& e) {
95521       {
95522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95523       };
95524     } catch (std::exception& e) {
95525       {
95526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95527       };
95528     } catch (Dali::DaliException e) {
95529       {
95530         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95531       };
95532     } catch (...) {
95533       {
95534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95535       };
95536     }
95537   }
95538
95539 }
95540
95541
95542 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Emit(void * jarg1, void * jarg2) {
95543   unsigned int jresult ;
95544   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95545   Dali::Toolkit::AccessibilityManager *arg2 = 0 ;
95546   bool result;
95547
95548   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95549   arg2 = (Dali::Toolkit::AccessibilityManager *)jarg2;
95550   if (!arg2) {
95551     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AccessibilityManager & type is null", 0);
95552     return 0;
95553   }
95554   {
95555     try {
95556       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Emit(arg1,*arg2);
95557     } catch (std::out_of_range& e) {
95558       {
95559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95560       };
95561     } catch (std::exception& e) {
95562       {
95563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95564       };
95565     } catch (Dali::DaliException e) {
95566       {
95567         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95568       };
95569     } catch (...) {
95570       {
95571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95572       };
95573     }
95574   }
95575
95576   jresult = result;
95577   return jresult;
95578 }
95579
95580
95581 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityActionSignal() {
95582   void * jresult ;
95583   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *result = 0 ;
95584
95585   {
95586     try {
95587       result = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)new Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) >();
95588     } catch (std::out_of_range& e) {
95589       {
95590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95591       };
95592     } catch (std::exception& e) {
95593       {
95594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95595       };
95596     } catch (Dali::DaliException e) {
95597       {
95598         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95599       };
95600     } catch (...) {
95601       {
95602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95603       };
95604     }
95605   }
95606
95607   jresult = (void *)result;
95608   return jresult;
95609 }
95610
95611
95612 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityActionSignal(void * jarg1) {
95613   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95614
95615   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95616   {
95617     try {
95618       delete arg1;
95619     } catch (std::out_of_range& e) {
95620       {
95621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95622       };
95623     } catch (std::exception& e) {
95624       {
95625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95626       };
95627     } catch (Dali::DaliException e) {
95628       {
95629         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95630       };
95631     } catch (...) {
95632       {
95633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95634       };
95635     }
95636   }
95637
95638 }
95639
95640
95641 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Empty(void * jarg1) {
95642   unsigned int jresult ;
95643   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
95644   bool result;
95645
95646   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
95647   {
95648     try {
95649       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);
95650     } catch (std::out_of_range& e) {
95651       {
95652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95653       };
95654     } catch (std::exception& e) {
95655       {
95656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95657       };
95658     } catch (Dali::DaliException e) {
95659       {
95660         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95661       };
95662     } catch (...) {
95663       {
95664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95665       };
95666     }
95667   }
95668
95669   jresult = result;
95670   return jresult;
95671 }
95672
95673
95674 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_GetConnectionCount(void * jarg1) {
95675   unsigned long jresult ;
95676   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
95677   std::size_t result;
95678
95679   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
95680   {
95681     try {
95682       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);
95683     } catch (std::out_of_range& e) {
95684       {
95685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95686       };
95687     } catch (std::exception& e) {
95688       {
95689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95690       };
95691     } catch (Dali::DaliException e) {
95692       {
95693         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95694       };
95695     } catch (...) {
95696       {
95697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95698       };
95699     }
95700   }
95701
95702   jresult = (unsigned long)result;
95703   return jresult;
95704 }
95705
95706
95707 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Connect(void * jarg1, void * jarg2) {
95708   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
95709   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
95710
95711   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
95712   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
95713   {
95714     try {
95715       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Connect(arg1,arg2);
95716     } catch (std::out_of_range& e) {
95717       {
95718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95719       };
95720     } catch (std::exception& e) {
95721       {
95722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95723       };
95724     } catch (Dali::DaliException e) {
95725       {
95726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95727       };
95728     } catch (...) {
95729       {
95730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95731       };
95732     }
95733   }
95734
95735 }
95736
95737
95738 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Disconnect(void * jarg1, void * jarg2) {
95739   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
95740   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
95741
95742   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
95743   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
95744   {
95745     try {
95746       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Disconnect(arg1,arg2);
95747     } catch (std::out_of_range& e) {
95748       {
95749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95750       };
95751     } catch (std::exception& e) {
95752       {
95753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95754       };
95755     } catch (Dali::DaliException e) {
95756       {
95757         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95758       };
95759     } catch (...) {
95760       {
95761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95762       };
95763     }
95764   }
95765
95766 }
95767
95768
95769 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
95770   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
95771   Dali::Actor arg2 ;
95772   Dali::Toolkit::AccessibilityManager::FocusOvershotDirection arg3 ;
95773   Dali::Actor *argp2 ;
95774
95775   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
95776   argp2 = (Dali::Actor *)jarg2;
95777   if (!argp2) {
95778     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
95779     return ;
95780   }
95781   arg2 = *argp2;
95782   arg3 = (Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)jarg3;
95783   {
95784     try {
95785       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Emit(arg1,arg2,arg3);
95786     } catch (std::out_of_range& e) {
95787       {
95788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95789       };
95790     } catch (std::exception& e) {
95791       {
95792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95793       };
95794     } catch (Dali::DaliException e) {
95795       {
95796         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95797       };
95798     } catch (...) {
95799       {
95800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95801       };
95802     }
95803   }
95804
95805 }
95806
95807
95808 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityFocusOvershotSignal() {
95809   void * jresult ;
95810   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *result = 0 ;
95811
95812   {
95813     try {
95814       result = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)new Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) >();
95815     } catch (std::out_of_range& e) {
95816       {
95817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95818       };
95819     } catch (std::exception& e) {
95820       {
95821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95822       };
95823     } catch (Dali::DaliException e) {
95824       {
95825         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95826       };
95827     } catch (...) {
95828       {
95829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95830       };
95831     }
95832   }
95833
95834   jresult = (void *)result;
95835   return jresult;
95836 }
95837
95838
95839 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityFocusOvershotSignal(void * jarg1) {
95840   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
95841
95842   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
95843   {
95844     try {
95845       delete arg1;
95846     } catch (std::out_of_range& e) {
95847       {
95848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95849       };
95850     } catch (std::exception& e) {
95851       {
95852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95853       };
95854     } catch (Dali::DaliException e) {
95855       {
95856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95857       };
95858     } catch (...) {
95859       {
95860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95861       };
95862     }
95863   }
95864
95865 }
95866
95867
95868 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Empty(void * jarg1) {
95869   unsigned int jresult ;
95870   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
95871   bool result;
95872
95873   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
95874   {
95875     try {
95876       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
95877     } catch (std::out_of_range& e) {
95878       {
95879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95880       };
95881     } catch (std::exception& e) {
95882       {
95883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95884       };
95885     } catch (Dali::DaliException e) {
95886       {
95887         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95888       };
95889     } catch (...) {
95890       {
95891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95892       };
95893     }
95894   }
95895
95896   jresult = result;
95897   return jresult;
95898 }
95899
95900
95901 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusChangedSignal_GetConnectionCount(void * jarg1) {
95902   unsigned long jresult ;
95903   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
95904   std::size_t result;
95905
95906   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
95907   {
95908     try {
95909       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
95910     } catch (std::out_of_range& e) {
95911       {
95912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95913       };
95914     } catch (std::exception& e) {
95915       {
95916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95917       };
95918     } catch (Dali::DaliException e) {
95919       {
95920         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95921       };
95922     } catch (...) {
95923       {
95924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95925       };
95926     }
95927   }
95928
95929   jresult = (unsigned long)result;
95930   return jresult;
95931 }
95932
95933
95934 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Connect(void * jarg1, void * jarg2) {
95935   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
95936   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
95937
95938   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
95939   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
95940   {
95941     try {
95942       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Connect(arg1,arg2);
95943     } catch (std::out_of_range& e) {
95944       {
95945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95946       };
95947     } catch (std::exception& e) {
95948       {
95949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95950       };
95951     } catch (Dali::DaliException e) {
95952       {
95953         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95954       };
95955     } catch (...) {
95956       {
95957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95958       };
95959     }
95960   }
95961
95962 }
95963
95964
95965 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Disconnect(void * jarg1, void * jarg2) {
95966   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
95967   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
95968
95969   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
95970   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
95971   {
95972     try {
95973       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
95974     } catch (std::out_of_range& e) {
95975       {
95976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95977       };
95978     } catch (std::exception& e) {
95979       {
95980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95981       };
95982     } catch (Dali::DaliException e) {
95983       {
95984         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95985       };
95986     } catch (...) {
95987       {
95988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95989       };
95990     }
95991   }
95992
95993 }
95994
95995
95996 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
95997   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
95998   Dali::Actor arg2 ;
95999   Dali::Actor arg3 ;
96000   Dali::Actor *argp2 ;
96001   Dali::Actor *argp3 ;
96002
96003   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
96004   argp2 = (Dali::Actor *)jarg2;
96005   if (!argp2) {
96006     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
96007     return ;
96008   }
96009   arg2 = *argp2;
96010   argp3 = (Dali::Actor *)jarg3;
96011   if (!argp3) {
96012     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
96013     return ;
96014   }
96015   arg3 = *argp3;
96016   {
96017     try {
96018       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Emit(arg1,arg2,arg3);
96019     } catch (std::out_of_range& e) {
96020       {
96021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96022       };
96023     } catch (std::exception& e) {
96024       {
96025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96026       };
96027     } catch (Dali::DaliException e) {
96028       {
96029         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96030       };
96031     } catch (...) {
96032       {
96033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96034       };
96035     }
96036   }
96037
96038 }
96039
96040
96041 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusChangedSignal() {
96042   void * jresult ;
96043   Dali::Signal< void (Dali::Actor,Dali::Actor) > *result = 0 ;
96044
96045   {
96046     try {
96047       result = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)new Dali::Signal< void (Dali::Actor,Dali::Actor) >();
96048     } catch (std::out_of_range& e) {
96049       {
96050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96051       };
96052     } catch (std::exception& e) {
96053       {
96054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96055       };
96056     } catch (Dali::DaliException e) {
96057       {
96058         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96059       };
96060     } catch (...) {
96061       {
96062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96063       };
96064     }
96065   }
96066
96067   jresult = (void *)result;
96068   return jresult;
96069 }
96070
96071
96072 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusChangedSignal(void * jarg1) {
96073   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
96074
96075   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
96076   {
96077     try {
96078       delete arg1;
96079     } catch (std::out_of_range& e) {
96080       {
96081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96082       };
96083     } catch (std::exception& e) {
96084       {
96085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96086       };
96087     } catch (Dali::DaliException e) {
96088       {
96089         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96090       };
96091     } catch (...) {
96092       {
96093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96094       };
96095     }
96096   }
96097
96098 }
96099
96100
96101 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Empty(void * jarg1) {
96102   unsigned int jresult ;
96103   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
96104   bool result;
96105
96106   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
96107   {
96108     try {
96109       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
96110     } catch (std::out_of_range& e) {
96111       {
96112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96113       };
96114     } catch (std::exception& e) {
96115       {
96116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96117       };
96118     } catch (Dali::DaliException e) {
96119       {
96120         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96121       };
96122     } catch (...) {
96123       {
96124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96125       };
96126     }
96127   }
96128
96129   jresult = result;
96130   return jresult;
96131 }
96132
96133
96134 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_GetConnectionCount(void * jarg1) {
96135   unsigned long jresult ;
96136   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
96137   std::size_t result;
96138
96139   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
96140   {
96141     try {
96142       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
96143     } catch (std::out_of_range& e) {
96144       {
96145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96146       };
96147     } catch (std::exception& e) {
96148       {
96149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96150       };
96151     } catch (Dali::DaliException e) {
96152       {
96153         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96154       };
96155     } catch (...) {
96156       {
96157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96158       };
96159     }
96160   }
96161
96162   jresult = (unsigned long)result;
96163   return jresult;
96164 }
96165
96166
96167 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Connect(void * jarg1, void * jarg2) {
96168   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
96169   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
96170
96171   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
96172   arg2 = (void (*)(Dali::Actor,bool))jarg2;
96173   {
96174     try {
96175       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Connect(arg1,arg2);
96176     } catch (std::out_of_range& e) {
96177       {
96178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96179       };
96180     } catch (std::exception& e) {
96181       {
96182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96183       };
96184     } catch (Dali::DaliException e) {
96185       {
96186         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96187       };
96188     } catch (...) {
96189       {
96190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96191       };
96192     }
96193   }
96194
96195 }
96196
96197
96198 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Disconnect(void * jarg1, void * jarg2) {
96199   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
96200   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
96201
96202   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
96203   arg2 = (void (*)(Dali::Actor,bool))jarg2;
96204   {
96205     try {
96206       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
96207     } catch (std::out_of_range& e) {
96208       {
96209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96210       };
96211     } catch (std::exception& e) {
96212       {
96213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96214       };
96215     } catch (Dali::DaliException e) {
96216       {
96217         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96218       };
96219     } catch (...) {
96220       {
96221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96222       };
96223     }
96224   }
96225
96226 }
96227
96228
96229 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3) {
96230   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
96231   Dali::Actor arg2 ;
96232   bool arg3 ;
96233   Dali::Actor *argp2 ;
96234
96235   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
96236   argp2 = (Dali::Actor *)jarg2;
96237   if (!argp2) {
96238     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
96239     return ;
96240   }
96241   arg2 = *argp2;
96242   arg3 = jarg3 ? true : false;
96243   {
96244     try {
96245       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3);
96246     } catch (std::out_of_range& e) {
96247       {
96248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96249       };
96250     } catch (std::exception& e) {
96251       {
96252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96253       };
96254     } catch (Dali::DaliException e) {
96255       {
96256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96257       };
96258     } catch (...) {
96259       {
96260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96261       };
96262     }
96263   }
96264
96265 }
96266
96267
96268 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusGroupChangedSignal() {
96269   void * jresult ;
96270   Dali::Signal< void (Dali::Actor,bool) > *result = 0 ;
96271
96272   {
96273     try {
96274       result = (Dali::Signal< void (Dali::Actor,bool) > *)new Dali::Signal< void (Dali::Actor,bool) >();
96275     } catch (std::out_of_range& e) {
96276       {
96277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96278       };
96279     } catch (std::exception& e) {
96280       {
96281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96282       };
96283     } catch (Dali::DaliException e) {
96284       {
96285         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96286       };
96287     } catch (...) {
96288       {
96289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96290       };
96291     }
96292   }
96293
96294   jresult = (void *)result;
96295   return jresult;
96296 }
96297
96298
96299 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusGroupChangedSignal(void * jarg1) {
96300   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
96301
96302   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
96303   {
96304     try {
96305       delete arg1;
96306     } catch (std::out_of_range& e) {
96307       {
96308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96309       };
96310     } catch (std::exception& e) {
96311       {
96312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96313       };
96314     } catch (Dali::DaliException e) {
96315       {
96316         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96317       };
96318     } catch (...) {
96319       {
96320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96321       };
96322     }
96323   }
96324
96325 }
96326
96327
96328 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Empty(void * jarg1) {
96329   unsigned int jresult ;
96330   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96331   bool result;
96332
96333   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96334   {
96335     try {
96336       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);
96337     } catch (std::out_of_range& e) {
96338       {
96339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96340       };
96341     } catch (std::exception& e) {
96342       {
96343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96344       };
96345     } catch (Dali::DaliException e) {
96346       {
96347         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96348       };
96349     } catch (...) {
96350       {
96351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96352       };
96353     }
96354   }
96355
96356   jresult = result;
96357   return jresult;
96358 }
96359
96360
96361 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StyleChangedSignal_GetConnectionCount(void * jarg1) {
96362   unsigned long jresult ;
96363   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96364   std::size_t result;
96365
96366   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96367   {
96368     try {
96369       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);
96370     } catch (std::out_of_range& e) {
96371       {
96372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96373       };
96374     } catch (std::exception& e) {
96375       {
96376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96377       };
96378     } catch (Dali::DaliException e) {
96379       {
96380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96381       };
96382     } catch (...) {
96383       {
96384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96385       };
96386     }
96387   }
96388
96389   jresult = (unsigned long)result;
96390   return jresult;
96391 }
96392
96393
96394 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Connect(void * jarg1, void * jarg2) {
96395   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96396   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
96397
96398   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96399   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
96400   {
96401     try {
96402       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Connect(arg1,arg2);
96403     } catch (std::out_of_range& e) {
96404       {
96405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96406       };
96407     } catch (std::exception& e) {
96408       {
96409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96410       };
96411     } catch (Dali::DaliException e) {
96412       {
96413         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96414       };
96415     } catch (...) {
96416       {
96417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96418       };
96419     }
96420   }
96421
96422 }
96423
96424
96425 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Disconnect(void * jarg1, void * jarg2) {
96426   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96427   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
96428
96429   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96430   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
96431   {
96432     try {
96433       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Disconnect(arg1,arg2);
96434     } catch (std::out_of_range& e) {
96435       {
96436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96437       };
96438     } catch (std::exception& e) {
96439       {
96440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96441       };
96442     } catch (Dali::DaliException e) {
96443       {
96444         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96445       };
96446     } catch (...) {
96447       {
96448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96449       };
96450     }
96451   }
96452
96453 }
96454
96455
96456 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
96457   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96458   Dali::Toolkit::StyleManager arg2 ;
96459   Dali::StyleChange::Type arg3 ;
96460   Dali::Toolkit::StyleManager *argp2 ;
96461
96462   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96463   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
96464   if (!argp2) {
96465     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
96466     return ;
96467   }
96468   arg2 = *argp2;
96469   arg3 = (Dali::StyleChange::Type)jarg3;
96470   {
96471     try {
96472       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Emit(arg1,arg2,arg3);
96473     } catch (std::out_of_range& e) {
96474       {
96475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96476       };
96477     } catch (std::exception& e) {
96478       {
96479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96480       };
96481     } catch (Dali::DaliException e) {
96482       {
96483         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96484       };
96485     } catch (...) {
96486       {
96487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96488       };
96489     }
96490   }
96491
96492 }
96493
96494
96495 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleChangedSignal() {
96496   void * jresult ;
96497   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *result = 0 ;
96498
96499   {
96500     try {
96501       result = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)new Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) >();
96502     } catch (std::out_of_range& e) {
96503       {
96504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96505       };
96506     } catch (std::exception& e) {
96507       {
96508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96509       };
96510     } catch (Dali::DaliException e) {
96511       {
96512         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96513       };
96514     } catch (...) {
96515       {
96516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96517       };
96518     }
96519   }
96520
96521   jresult = (void *)result;
96522   return jresult;
96523 }
96524
96525
96526 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleChangedSignal(void * jarg1) {
96527   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96528
96529   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96530   {
96531     try {
96532       delete arg1;
96533     } catch (std::out_of_range& e) {
96534       {
96535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96536       };
96537     } catch (std::exception& e) {
96538       {
96539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96540       };
96541     } catch (Dali::DaliException e) {
96542       {
96543         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96544       };
96545     } catch (...) {
96546       {
96547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96548       };
96549     }
96550   }
96551
96552 }
96553
96554
96555 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Empty(void * jarg1) {
96556   unsigned int jresult ;
96557   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96558   bool result;
96559
96560   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96561   {
96562     try {
96563       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
96564     } catch (std::out_of_range& e) {
96565       {
96566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96567       };
96568     } catch (std::exception& e) {
96569       {
96570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96571       };
96572     } catch (Dali::DaliException e) {
96573       {
96574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96575       };
96576     } catch (...) {
96577       {
96578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96579       };
96580     }
96581   }
96582
96583   jresult = result;
96584   return jresult;
96585 }
96586
96587
96588 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ButtonSignal_GetConnectionCount(void * jarg1) {
96589   unsigned long jresult ;
96590   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96591   std::size_t result;
96592
96593   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96594   {
96595     try {
96596       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
96597     } catch (std::out_of_range& e) {
96598       {
96599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96600       };
96601     } catch (std::exception& e) {
96602       {
96603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96604       };
96605     } catch (Dali::DaliException e) {
96606       {
96607         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96608       };
96609     } catch (...) {
96610       {
96611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96612       };
96613     }
96614   }
96615
96616   jresult = (unsigned long)result;
96617   return jresult;
96618 }
96619
96620
96621 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Connect(void * jarg1, void * jarg2) {
96622   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96623   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
96624
96625   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96626   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
96627   {
96628     try {
96629       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Connect(arg1,arg2);
96630     } catch (std::out_of_range& e) {
96631       {
96632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96633       };
96634     } catch (std::exception& e) {
96635       {
96636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96637       };
96638     } catch (Dali::DaliException e) {
96639       {
96640         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96641       };
96642     } catch (...) {
96643       {
96644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96645       };
96646     }
96647   }
96648
96649 }
96650
96651
96652 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Disconnect(void * jarg1, void * jarg2) {
96653   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96654   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
96655
96656   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96657   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
96658   {
96659     try {
96660       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Disconnect(arg1,arg2);
96661     } catch (std::out_of_range& e) {
96662       {
96663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96664       };
96665     } catch (std::exception& e) {
96666       {
96667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96668       };
96669     } catch (Dali::DaliException e) {
96670       {
96671         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96672       };
96673     } catch (...) {
96674       {
96675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96676       };
96677     }
96678   }
96679
96680 }
96681
96682
96683 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Emit(void * jarg1, void * jarg2) {
96684   unsigned int jresult ;
96685   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96686   Dali::Toolkit::Button arg2 ;
96687   Dali::Toolkit::Button *argp2 ;
96688   bool result;
96689
96690   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96691   argp2 = (Dali::Toolkit::Button *)jarg2;
96692   if (!argp2) {
96693     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Button", 0);
96694     return 0;
96695   }
96696   arg2 = *argp2;
96697   {
96698     try {
96699       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(arg1,arg2);
96700     } catch (std::out_of_range& e) {
96701       {
96702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96703       };
96704     } catch (std::exception& e) {
96705       {
96706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96707       };
96708     } catch (Dali::DaliException e) {
96709       {
96710         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96711       };
96712     } catch (...) {
96713       {
96714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96715       };
96716     }
96717   }
96718
96719   jresult = result;
96720   return jresult;
96721 }
96722
96723
96724 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ButtonSignal() {
96725   void * jresult ;
96726   Dali::Signal< bool (Dali::Toolkit::Button) > *result = 0 ;
96727
96728   {
96729     try {
96730       result = (Dali::Signal< bool (Dali::Toolkit::Button) > *)new Dali::Signal< bool (Dali::Toolkit::Button) >();
96731     } catch (std::out_of_range& e) {
96732       {
96733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96734       };
96735     } catch (std::exception& e) {
96736       {
96737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96738       };
96739     } catch (Dali::DaliException e) {
96740       {
96741         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96742       };
96743     } catch (...) {
96744       {
96745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96746       };
96747     }
96748   }
96749
96750   jresult = (void *)result;
96751   return jresult;
96752 }
96753
96754
96755 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ButtonSignal(void * jarg1) {
96756   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96757
96758   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96759   {
96760     try {
96761       delete arg1;
96762     } catch (std::out_of_range& e) {
96763       {
96764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96765       };
96766     } catch (std::exception& e) {
96767       {
96768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96769       };
96770     } catch (Dali::DaliException e) {
96771       {
96772         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96773       };
96774     } catch (...) {
96775       {
96776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96777       };
96778     }
96779   }
96780
96781 }
96782
96783
96784 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Empty(void * jarg1) {
96785   unsigned int jresult ;
96786   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
96787   bool result;
96788
96789   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
96790   {
96791     try {
96792       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
96793     } catch (std::out_of_range& e) {
96794       {
96795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96796       };
96797     } catch (std::exception& e) {
96798       {
96799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96800       };
96801     } catch (Dali::DaliException e) {
96802       {
96803         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96804       };
96805     } catch (...) {
96806       {
96807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96808       };
96809     }
96810   }
96811
96812   jresult = result;
96813   return jresult;
96814 }
96815
96816
96817 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_GetConnectionCount(void * jarg1) {
96818   unsigned long jresult ;
96819   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
96820   std::size_t result;
96821
96822   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
96823   {
96824     try {
96825       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
96826     } catch (std::out_of_range& e) {
96827       {
96828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96829       };
96830     } catch (std::exception& e) {
96831       {
96832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96833       };
96834     } catch (Dali::DaliException e) {
96835       {
96836         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96837       };
96838     } catch (...) {
96839       {
96840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96841       };
96842     }
96843   }
96844
96845   jresult = (unsigned long)result;
96846   return jresult;
96847 }
96848
96849
96850 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Connect(void * jarg1, void * jarg2) {
96851   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
96852   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
96853
96854   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
96855   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
96856   {
96857     try {
96858       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Connect(arg1,arg2);
96859     } catch (std::out_of_range& e) {
96860       {
96861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96862       };
96863     } catch (std::exception& e) {
96864       {
96865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96866       };
96867     } catch (Dali::DaliException e) {
96868       {
96869         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96870       };
96871     } catch (...) {
96872       {
96873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96874       };
96875     }
96876   }
96877
96878 }
96879
96880
96881 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Disconnect(void * jarg1, void * jarg2) {
96882   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
96883   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
96884
96885   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
96886   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
96887   {
96888     try {
96889       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Disconnect(arg1,arg2);
96890     } catch (std::out_of_range& e) {
96891       {
96892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96893       };
96894     } catch (std::exception& e) {
96895       {
96896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96897       };
96898     } catch (Dali::DaliException e) {
96899       {
96900         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96901       };
96902     } catch (...) {
96903       {
96904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96905       };
96906     }
96907   }
96908
96909 }
96910
96911
96912 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Emit(void * jarg1, void * jarg2) {
96913   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
96914   Dali::Toolkit::GaussianBlurView arg2 ;
96915   Dali::Toolkit::GaussianBlurView *argp2 ;
96916
96917   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
96918   argp2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
96919   if (!argp2) {
96920     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::GaussianBlurView", 0);
96921     return ;
96922   }
96923   arg2 = *argp2;
96924   {
96925     try {
96926       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(arg1,arg2);
96927     } catch (std::out_of_range& e) {
96928       {
96929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96930       };
96931     } catch (std::exception& e) {
96932       {
96933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96934       };
96935     } catch (Dali::DaliException e) {
96936       {
96937         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96938       };
96939     } catch (...) {
96940       {
96941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96942       };
96943     }
96944   }
96945
96946 }
96947
96948
96949 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurViewSignal() {
96950   void * jresult ;
96951   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *result = 0 ;
96952
96953   {
96954     try {
96955       result = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)new Dali::Signal< void (Dali::Toolkit::GaussianBlurView) >();
96956     } catch (std::out_of_range& e) {
96957       {
96958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96959       };
96960     } catch (std::exception& e) {
96961       {
96962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96963       };
96964     } catch (Dali::DaliException e) {
96965       {
96966         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96967       };
96968     } catch (...) {
96969       {
96970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96971       };
96972     }
96973   }
96974
96975   jresult = (void *)result;
96976   return jresult;
96977 }
96978
96979
96980 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurViewSignal(void * jarg1) {
96981   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
96982
96983   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
96984   {
96985     try {
96986       delete arg1;
96987     } catch (std::out_of_range& e) {
96988       {
96989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96990       };
96991     } catch (std::exception& e) {
96992       {
96993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96994       };
96995     } catch (Dali::DaliException e) {
96996       {
96997         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96998       };
96999     } catch (...) {
97000       {
97001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97002       };
97003     }
97004   }
97005
97006 }
97007
97008
97009 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageTurnSignal_Empty(void * jarg1) {
97010   unsigned int jresult ;
97011   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
97012   bool result;
97013
97014   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
97015   {
97016     try {
97017       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);
97018     } catch (std::out_of_range& e) {
97019       {
97020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97021       };
97022     } catch (std::exception& e) {
97023       {
97024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97025       };
97026     } catch (Dali::DaliException e) {
97027       {
97028         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97029       };
97030     } catch (...) {
97031       {
97032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97033       };
97034     }
97035   }
97036
97037   jresult = result;
97038   return jresult;
97039 }
97040
97041
97042 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PageTurnSignal_GetConnectionCount(void * jarg1) {
97043   unsigned long jresult ;
97044   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
97045   std::size_t result;
97046
97047   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
97048   {
97049     try {
97050       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);
97051     } catch (std::out_of_range& e) {
97052       {
97053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97054       };
97055     } catch (std::exception& e) {
97056       {
97057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97058       };
97059     } catch (Dali::DaliException e) {
97060       {
97061         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97062       };
97063     } catch (...) {
97064       {
97065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97066       };
97067     }
97068   }
97069
97070   jresult = (unsigned long)result;
97071   return jresult;
97072 }
97073
97074
97075 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Connect(void * jarg1, void * jarg2) {
97076   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
97077   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
97078
97079   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
97080   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
97081   {
97082     try {
97083       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Connect(arg1,arg2);
97084     } catch (std::out_of_range& e) {
97085       {
97086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97087       };
97088     } catch (std::exception& e) {
97089       {
97090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97091       };
97092     } catch (Dali::DaliException e) {
97093       {
97094         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97095       };
97096     } catch (...) {
97097       {
97098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97099       };
97100     }
97101   }
97102
97103 }
97104
97105
97106 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Disconnect(void * jarg1, void * jarg2) {
97107   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
97108   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
97109
97110   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
97111   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
97112   {
97113     try {
97114       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
97115     } catch (std::out_of_range& e) {
97116       {
97117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97118       };
97119     } catch (std::exception& e) {
97120       {
97121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97122       };
97123     } catch (Dali::DaliException e) {
97124       {
97125         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97126       };
97127     } catch (...) {
97128       {
97129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97130       };
97131     }
97132   }
97133
97134 }
97135
97136
97137 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
97138   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
97139   Dali::Toolkit::PageTurnView arg2 ;
97140   unsigned int arg3 ;
97141   bool arg4 ;
97142   Dali::Toolkit::PageTurnView *argp2 ;
97143
97144   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
97145   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
97146   if (!argp2) {
97147     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
97148     return ;
97149   }
97150   arg2 = *argp2;
97151   arg3 = (unsigned int)jarg3;
97152   arg4 = jarg4 ? true : false;
97153   {
97154     try {
97155       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3,arg4);
97156     } catch (std::out_of_range& e) {
97157       {
97158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97159       };
97160     } catch (std::exception& e) {
97161       {
97162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97163       };
97164     } catch (Dali::DaliException e) {
97165       {
97166         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97167       };
97168     } catch (...) {
97169       {
97170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97171       };
97172     }
97173   }
97174
97175 }
97176
97177
97178 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnSignal() {
97179   void * jresult ;
97180   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *result = 0 ;
97181
97182   {
97183     try {
97184       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) >();
97185     } catch (std::out_of_range& e) {
97186       {
97187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97188       };
97189     } catch (std::exception& e) {
97190       {
97191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97192       };
97193     } catch (Dali::DaliException e) {
97194       {
97195         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97196       };
97197     } catch (...) {
97198       {
97199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97200       };
97201     }
97202   }
97203
97204   jresult = (void *)result;
97205   return jresult;
97206 }
97207
97208
97209 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnSignal(void * jarg1) {
97210   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
97211
97212   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
97213   {
97214     try {
97215       delete arg1;
97216     } catch (std::out_of_range& e) {
97217       {
97218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97219       };
97220     } catch (std::exception& e) {
97221       {
97222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97223       };
97224     } catch (Dali::DaliException e) {
97225       {
97226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97227       };
97228     } catch (...) {
97229       {
97230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97231       };
97232     }
97233   }
97234
97235 }
97236
97237
97238 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PagePanSignal_Empty(void * jarg1) {
97239   unsigned int jresult ;
97240   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97241   bool result;
97242
97243   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97244   {
97245     try {
97246       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
97247     } catch (std::out_of_range& e) {
97248       {
97249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97250       };
97251     } catch (std::exception& e) {
97252       {
97253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97254       };
97255     } catch (Dali::DaliException e) {
97256       {
97257         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97258       };
97259     } catch (...) {
97260       {
97261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97262       };
97263     }
97264   }
97265
97266   jresult = result;
97267   return jresult;
97268 }
97269
97270
97271 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PagePanSignal_GetConnectionCount(void * jarg1) {
97272   unsigned long jresult ;
97273   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97274   std::size_t result;
97275
97276   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97277   {
97278     try {
97279       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
97280     } catch (std::out_of_range& e) {
97281       {
97282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97283       };
97284     } catch (std::exception& e) {
97285       {
97286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97287       };
97288     } catch (Dali::DaliException e) {
97289       {
97290         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97291       };
97292     } catch (...) {
97293       {
97294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97295       };
97296     }
97297   }
97298
97299   jresult = (unsigned long)result;
97300   return jresult;
97301 }
97302
97303
97304 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Connect(void * jarg1, void * jarg2) {
97305   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97306   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
97307
97308   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97309   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
97310   {
97311     try {
97312       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Connect(arg1,arg2);
97313     } catch (std::out_of_range& e) {
97314       {
97315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97316       };
97317     } catch (std::exception& e) {
97318       {
97319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97320       };
97321     } catch (Dali::DaliException e) {
97322       {
97323         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97324       };
97325     } catch (...) {
97326       {
97327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97328       };
97329     }
97330   }
97331
97332 }
97333
97334
97335 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Disconnect(void * jarg1, void * jarg2) {
97336   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97337   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
97338
97339   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97340   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
97341   {
97342     try {
97343       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Disconnect(arg1,arg2);
97344     } catch (std::out_of_range& e) {
97345       {
97346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97347       };
97348     } catch (std::exception& e) {
97349       {
97350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97351       };
97352     } catch (Dali::DaliException e) {
97353       {
97354         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97355       };
97356     } catch (...) {
97357       {
97358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97359       };
97360     }
97361   }
97362
97363 }
97364
97365
97366 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Emit(void * jarg1, void * jarg2) {
97367   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97368   Dali::Toolkit::PageTurnView arg2 ;
97369   Dali::Toolkit::PageTurnView *argp2 ;
97370
97371   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97372   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
97373   if (!argp2) {
97374     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
97375     return ;
97376   }
97377   arg2 = *argp2;
97378   {
97379     try {
97380       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(arg1,arg2);
97381     } catch (std::out_of_range& e) {
97382       {
97383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97384       };
97385     } catch (std::exception& e) {
97386       {
97387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97388       };
97389     } catch (Dali::DaliException e) {
97390       {
97391         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97392       };
97393     } catch (...) {
97394       {
97395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97396       };
97397     }
97398   }
97399
97400 }
97401
97402
97403 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PagePanSignal() {
97404   void * jresult ;
97405   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *result = 0 ;
97406
97407   {
97408     try {
97409       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView) >();
97410     } catch (std::out_of_range& e) {
97411       {
97412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97413       };
97414     } catch (std::exception& e) {
97415       {
97416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97417       };
97418     } catch (Dali::DaliException e) {
97419       {
97420         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97421       };
97422     } catch (...) {
97423       {
97424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97425       };
97426     }
97427   }
97428
97429   jresult = (void *)result;
97430   return jresult;
97431 }
97432
97433
97434 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PagePanSignal(void * jarg1) {
97435   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97436
97437   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97438   {
97439     try {
97440       delete arg1;
97441     } catch (std::out_of_range& e) {
97442       {
97443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97444       };
97445     } catch (std::exception& e) {
97446       {
97447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97448       };
97449     } catch (Dali::DaliException e) {
97450       {
97451         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97452       };
97453     } catch (...) {
97454       {
97455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97456       };
97457     }
97458   }
97459
97460 }
97461
97462
97463 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Empty(void * jarg1) {
97464   unsigned int jresult ;
97465   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97466   bool result;
97467
97468   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97469   {
97470     try {
97471       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);
97472     } catch (std::out_of_range& e) {
97473       {
97474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97475       };
97476     } catch (std::exception& e) {
97477       {
97478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97479       };
97480     } catch (Dali::DaliException e) {
97481       {
97482         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97483       };
97484     } catch (...) {
97485       {
97486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97487       };
97488     }
97489   }
97490
97491   jresult = result;
97492   return jresult;
97493 }
97494
97495
97496 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_GetConnectionCount(void * jarg1) {
97497   unsigned long jresult ;
97498   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97499   std::size_t result;
97500
97501   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97502   {
97503     try {
97504       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);
97505     } catch (std::out_of_range& e) {
97506       {
97507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97508       };
97509     } catch (std::exception& e) {
97510       {
97511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97512       };
97513     } catch (Dali::DaliException e) {
97514       {
97515         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97516       };
97517     } catch (...) {
97518       {
97519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97520       };
97521     }
97522   }
97523
97524   jresult = (unsigned long)result;
97525   return jresult;
97526 }
97527
97528
97529 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Connect(void * jarg1, void * jarg2) {
97530   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97531   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
97532
97533   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97534   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
97535   {
97536     try {
97537       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Connect(arg1,arg2);
97538     } catch (std::out_of_range& e) {
97539       {
97540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97541       };
97542     } catch (std::exception& e) {
97543       {
97544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97545       };
97546     } catch (Dali::DaliException e) {
97547       {
97548         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97549       };
97550     } catch (...) {
97551       {
97552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97553       };
97554     }
97555   }
97556
97557 }
97558
97559
97560 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
97561   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97562   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
97563
97564   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97565   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
97566   {
97567     try {
97568       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Disconnect(arg1,arg2);
97569     } catch (std::out_of_range& e) {
97570       {
97571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97572       };
97573     } catch (std::exception& e) {
97574       {
97575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97576       };
97577     } catch (Dali::DaliException e) {
97578       {
97579         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97580       };
97581     } catch (...) {
97582       {
97583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97584       };
97585     }
97586   }
97587
97588 }
97589
97590
97591 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3, float jarg4) {
97592   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97593   Dali::Toolkit::ProgressBar arg2 ;
97594   float arg3 ;
97595   float arg4 ;
97596   Dali::Toolkit::ProgressBar *argp2 ;
97597
97598   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97599   argp2 = (Dali::Toolkit::ProgressBar *)jarg2;
97600   if (!argp2) {
97601     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ProgressBar", 0);
97602     return ;
97603   }
97604   arg2 = *argp2;
97605   arg3 = (float)jarg3;
97606   arg4 = (float)jarg4;
97607   {
97608     try {
97609       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Emit(arg1,arg2,arg3,arg4);
97610     } catch (std::out_of_range& e) {
97611       {
97612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97613       };
97614     } catch (std::exception& e) {
97615       {
97616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97617       };
97618     } catch (Dali::DaliException e) {
97619       {
97620         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97621       };
97622     } catch (...) {
97623       {
97624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97625       };
97626     }
97627   }
97628
97629 }
97630
97631
97632 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBarValueChangedSignal() {
97633   void * jresult ;
97634   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *result = 0 ;
97635
97636   {
97637     try {
97638       result = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)new Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) >();
97639     } catch (std::out_of_range& e) {
97640       {
97641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97642       };
97643     } catch (std::exception& e) {
97644       {
97645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97646       };
97647     } catch (Dali::DaliException e) {
97648       {
97649         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97650       };
97651     } catch (...) {
97652       {
97653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97654       };
97655     }
97656   }
97657
97658   jresult = (void *)result;
97659   return jresult;
97660 }
97661
97662
97663 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBarValueChangedSignal(void * jarg1) {
97664   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97665
97666   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97667   {
97668     try {
97669       delete arg1;
97670     } catch (std::out_of_range& e) {
97671       {
97672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97673       };
97674     } catch (std::exception& e) {
97675       {
97676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97677       };
97678     } catch (Dali::DaliException e) {
97679       {
97680         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97681       };
97682     } catch (...) {
97683       {
97684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97685       };
97686     }
97687   }
97688
97689 }
97690
97691
97692 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Empty(void * jarg1) {
97693   unsigned int jresult ;
97694   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
97695   bool result;
97696
97697   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
97698   {
97699     try {
97700       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);
97701     } catch (std::out_of_range& e) {
97702       {
97703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97704       };
97705     } catch (std::exception& e) {
97706       {
97707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97708       };
97709     } catch (Dali::DaliException e) {
97710       {
97711         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97712       };
97713     } catch (...) {
97714       {
97715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97716       };
97717     }
97718   }
97719
97720   jresult = result;
97721   return jresult;
97722 }
97723
97724
97725 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_GetConnectionCount(void * jarg1) {
97726   unsigned long jresult ;
97727   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
97728   std::size_t result;
97729
97730   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
97731   {
97732     try {
97733       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);
97734     } catch (std::out_of_range& e) {
97735       {
97736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97737       };
97738     } catch (std::exception& e) {
97739       {
97740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97741       };
97742     } catch (Dali::DaliException e) {
97743       {
97744         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97745       };
97746     } catch (...) {
97747       {
97748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97749       };
97750     }
97751   }
97752
97753   jresult = (unsigned long)result;
97754   return jresult;
97755 }
97756
97757
97758 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Connect(void * jarg1, void * jarg2) {
97759   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
97760   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
97761
97762   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
97763   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
97764   {
97765     try {
97766       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
97767     } catch (std::out_of_range& e) {
97768       {
97769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97770       };
97771     } catch (std::exception& e) {
97772       {
97773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97774       };
97775     } catch (Dali::DaliException e) {
97776       {
97777         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97778       };
97779     } catch (...) {
97780       {
97781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97782       };
97783     }
97784   }
97785
97786 }
97787
97788
97789 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Disconnect(void * jarg1, void * jarg2) {
97790   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
97791   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
97792
97793   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
97794   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
97795   {
97796     try {
97797       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
97798     } catch (std::out_of_range& e) {
97799       {
97800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97801       };
97802     } catch (std::exception& e) {
97803       {
97804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97805       };
97806     } catch (Dali::DaliException e) {
97807       {
97808         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97809       };
97810     } catch (...) {
97811       {
97812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97813       };
97814     }
97815   }
97816
97817 }
97818
97819
97820 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Emit(void * jarg1, void * jarg2) {
97821   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
97822   Dali::Toolkit::ScrollView::SnapEvent *arg2 = 0 ;
97823
97824   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
97825   arg2 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg2;
97826   if (!arg2) {
97827     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView::SnapEvent const & type is null", 0);
97828     return ;
97829   }
97830   {
97831     try {
97832       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Toolkit::ScrollView::SnapEvent const &)*arg2);
97833     } catch (std::out_of_range& e) {
97834       {
97835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97836       };
97837     } catch (std::exception& e) {
97838       {
97839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97840       };
97841     } catch (Dali::DaliException e) {
97842       {
97843         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97844       };
97845     } catch (...) {
97846       {
97847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97848       };
97849     }
97850   }
97851
97852 }
97853
97854
97855 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewSnapStartedSignal() {
97856   void * jresult ;
97857   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *result = 0 ;
97858
97859   {
97860     try {
97861       result = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)new Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) >();
97862     } catch (std::out_of_range& e) {
97863       {
97864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97865       };
97866     } catch (std::exception& e) {
97867       {
97868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97869       };
97870     } catch (Dali::DaliException e) {
97871       {
97872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97873       };
97874     } catch (...) {
97875       {
97876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97877       };
97878     }
97879   }
97880
97881   jresult = (void *)result;
97882   return jresult;
97883 }
97884
97885
97886 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewSnapStartedSignal(void * jarg1) {
97887   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
97888
97889   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
97890   {
97891     try {
97892       delete arg1;
97893     } catch (std::out_of_range& e) {
97894       {
97895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97896       };
97897     } catch (std::exception& e) {
97898       {
97899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97900       };
97901     } catch (Dali::DaliException e) {
97902       {
97903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97904       };
97905     } catch (...) {
97906       {
97907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97908       };
97909     }
97910   }
97911
97912 }
97913
97914
97915 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollableSignal_Empty(void * jarg1) {
97916   unsigned int jresult ;
97917   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
97918   bool result;
97919
97920   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
97921   {
97922     try {
97923       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
97924     } catch (std::out_of_range& e) {
97925       {
97926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97927       };
97928     } catch (std::exception& e) {
97929       {
97930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97931       };
97932     } catch (Dali::DaliException e) {
97933       {
97934         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97935       };
97936     } catch (...) {
97937       {
97938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97939       };
97940     }
97941   }
97942
97943   jresult = result;
97944   return jresult;
97945 }
97946
97947
97948 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollableSignal_GetConnectionCount(void * jarg1) {
97949   unsigned long jresult ;
97950   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
97951   std::size_t result;
97952
97953   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
97954   {
97955     try {
97956       result = Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
97957     } catch (std::out_of_range& e) {
97958       {
97959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97960       };
97961     } catch (std::exception& e) {
97962       {
97963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97964       };
97965     } catch (Dali::DaliException e) {
97966       {
97967         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97968       };
97969     } catch (...) {
97970       {
97971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97972       };
97973     }
97974   }
97975
97976   jresult = (unsigned long)result;
97977   return jresult;
97978 }
97979
97980
97981 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Connect(void * jarg1, void * jarg2) {
97982   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
97983   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
97984
97985   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
97986   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
97987   {
97988     try {
97989       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Connect(arg1,arg2);
97990     } catch (std::out_of_range& e) {
97991       {
97992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97993       };
97994     } catch (std::exception& e) {
97995       {
97996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97997       };
97998     } catch (Dali::DaliException e) {
97999       {
98000         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98001       };
98002     } catch (...) {
98003       {
98004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98005       };
98006     }
98007   }
98008
98009 }
98010
98011
98012 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Disconnect(void * jarg1, void * jarg2) {
98013   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
98014   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
98015
98016   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
98017   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
98018   {
98019     try {
98020       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
98021     } catch (std::out_of_range& e) {
98022       {
98023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98024       };
98025     } catch (std::exception& e) {
98026       {
98027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98028       };
98029     } catch (Dali::DaliException e) {
98030       {
98031         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98032       };
98033     } catch (...) {
98034       {
98035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98036       };
98037     }
98038   }
98039
98040 }
98041
98042
98043 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Emit(void * jarg1, void * jarg2) {
98044   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
98045   Dali::Vector2 *arg2 = 0 ;
98046
98047   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
98048   arg2 = (Dali::Vector2 *)jarg2;
98049   if (!arg2) {
98050     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
98051     return ;
98052   }
98053   {
98054     try {
98055       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Vector2 const &)*arg2);
98056     } catch (std::out_of_range& e) {
98057       {
98058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98059       };
98060     } catch (std::exception& e) {
98061       {
98062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98063       };
98064     } catch (Dali::DaliException e) {
98065       {
98066         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98067       };
98068     } catch (...) {
98069       {
98070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98071       };
98072     }
98073   }
98074
98075 }
98076
98077
98078 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollableSignal() {
98079   void * jresult ;
98080   Dali::Signal< void (Dali::Vector2 const &) > *result = 0 ;
98081
98082   {
98083     try {
98084       result = (Dali::Signal< void (Dali::Vector2 const &) > *)new Dali::Signal< void (Dali::Vector2 const &) >();
98085     } catch (std::out_of_range& e) {
98086       {
98087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98088       };
98089     } catch (std::exception& e) {
98090       {
98091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98092       };
98093     } catch (Dali::DaliException e) {
98094       {
98095         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98096       };
98097     } catch (...) {
98098       {
98099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98100       };
98101     }
98102   }
98103
98104   jresult = (void *)result;
98105   return jresult;
98106 }
98107
98108
98109 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollableSignal(void * jarg1) {
98110   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
98111
98112   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
98113   {
98114     try {
98115       delete arg1;
98116     } catch (std::out_of_range& e) {
98117       {
98118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98119       };
98120     } catch (std::exception& e) {
98121       {
98122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98123       };
98124     } catch (Dali::DaliException e) {
98125       {
98126         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98127       };
98128     } catch (...) {
98129       {
98130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98131       };
98132     }
98133   }
98134
98135 }
98136
98137
98138
98139 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Empty(void * jarg1) {
98140   unsigned int jresult ;
98141   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
98142   bool result;
98143
98144   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
98145   {
98146     try {
98147       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);
98148     } catch (std::out_of_range& e) {
98149       {
98150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98151       };
98152     } catch (std::exception& e) {
98153       {
98154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98155       };
98156     } catch (Dali::DaliException e) {
98157       {
98158         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98159       };
98160     } catch (...) {
98161       {
98162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98163       };
98164     }
98165   }
98166
98167   jresult = result;
98168   return jresult;
98169 }
98170
98171
98172 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ControlKeySignal_GetConnectionCount(void * jarg1) {
98173   unsigned long jresult ;
98174   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
98175   std::size_t result;
98176
98177   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
98178   {
98179     try {
98180       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);
98181     } catch (std::out_of_range& e) {
98182       {
98183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98184       };
98185     } catch (std::exception& e) {
98186       {
98187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98188       };
98189     } catch (Dali::DaliException e) {
98190       {
98191         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98192       };
98193     } catch (...) {
98194       {
98195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98196       };
98197     }
98198   }
98199
98200   jresult = (unsigned long)result;
98201   return jresult;
98202 }
98203
98204
98205 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Connect(void * jarg1, void * jarg2) {
98206   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
98207   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
98208
98209   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
98210   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
98211   {
98212     try {
98213       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
98214     } catch (std::out_of_range& e) {
98215       {
98216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98217       };
98218     } catch (std::exception& e) {
98219       {
98220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98221       };
98222     } catch (Dali::DaliException e) {
98223       {
98224         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98225       };
98226     } catch (...) {
98227       {
98228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98229       };
98230     }
98231   }
98232
98233 }
98234
98235
98236 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Disconnect(void * jarg1, void * jarg2) {
98237   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
98238   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
98239
98240   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
98241   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
98242   {
98243     try {
98244       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
98245     } catch (std::out_of_range& e) {
98246       {
98247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98248       };
98249     } catch (std::exception& e) {
98250       {
98251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98252       };
98253     } catch (Dali::DaliException e) {
98254       {
98255         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98256       };
98257     } catch (...) {
98258       {
98259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98260       };
98261     }
98262   }
98263
98264 }
98265
98266
98267 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
98268   unsigned int jresult ;
98269   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
98270   Dali::Toolkit::Control arg2 ;
98271   Dali::KeyEvent *arg3 = 0 ;
98272   Dali::Toolkit::Control *argp2 ;
98273   bool result;
98274
98275   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
98276   argp2 = (Dali::Toolkit::Control *)jarg2;
98277   if (!argp2) {
98278     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
98279     return 0;
98280   }
98281   arg2 = *argp2;
98282   arg3 = (Dali::KeyEvent *)jarg3;
98283   if (!arg3) {
98284     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
98285     return 0;
98286   }
98287   {
98288     try {
98289       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);
98290     } catch (std::out_of_range& e) {
98291       {
98292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98293       };
98294     } catch (std::exception& e) {
98295       {
98296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98297       };
98298     } catch (Dali::DaliException e) {
98299       {
98300         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98301       };
98302     } catch (...) {
98303       {
98304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98305       };
98306     }
98307   }
98308
98309   jresult = result;
98310   return jresult;
98311 }
98312
98313
98314 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ControlKeySignal() {
98315   void * jresult ;
98316   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *result = 0 ;
98317
98318   {
98319     try {
98320       result = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)new Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) >();
98321     } catch (std::out_of_range& e) {
98322       {
98323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98324       };
98325     } catch (std::exception& e) {
98326       {
98327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98328       };
98329     } catch (Dali::DaliException e) {
98330       {
98331         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98332       };
98333     } catch (...) {
98334       {
98335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98336       };
98337     }
98338   }
98339
98340   jresult = (void *)result;
98341   return jresult;
98342 }
98343
98344
98345 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ControlKeySignal(void * jarg1) {
98346   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
98347
98348   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
98349   {
98350     try {
98351       delete arg1;
98352     } catch (std::out_of_range& e) {
98353       {
98354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98355       };
98356     } catch (std::exception& e) {
98357       {
98358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98359       };
98360     } catch (Dali::DaliException e) {
98361       {
98362         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98363       };
98364     } catch (...) {
98365       {
98366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98367       };
98368     }
98369   }
98370
98371 }
98372
98373
98374 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Empty(void * jarg1) {
98375   unsigned int jresult ;
98376   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98377   bool result;
98378
98379   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98380   {
98381     try {
98382       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
98383     } catch (std::out_of_range& e) {
98384       {
98385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98386       };
98387     } catch (std::exception& e) {
98388       {
98389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98390       };
98391     } catch (Dali::DaliException e) {
98392       {
98393         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98394       };
98395     } catch (...) {
98396       {
98397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98398       };
98399     }
98400   }
98401
98402   jresult = result;
98403   return jresult;
98404 }
98405
98406
98407 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_GetConnectionCount(void * jarg1) {
98408   unsigned long jresult ;
98409   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98410   std::size_t result;
98411
98412   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98413   {
98414     try {
98415       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
98416     } catch (std::out_of_range& e) {
98417       {
98418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98419       };
98420     } catch (std::exception& e) {
98421       {
98422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98423       };
98424     } catch (Dali::DaliException e) {
98425       {
98426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98427       };
98428     } catch (...) {
98429       {
98430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98431       };
98432     }
98433   }
98434
98435   jresult = (unsigned long)result;
98436   return jresult;
98437 }
98438
98439
98440 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Connect(void * jarg1, void * jarg2) {
98441   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98442   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
98443
98444   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98445   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
98446   {
98447     try {
98448       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
98449     } catch (std::out_of_range& e) {
98450       {
98451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98452       };
98453     } catch (std::exception& e) {
98454       {
98455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98456       };
98457     } catch (Dali::DaliException e) {
98458       {
98459         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98460       };
98461     } catch (...) {
98462       {
98463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98464       };
98465     }
98466   }
98467
98468 }
98469
98470
98471 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Disconnect(void * jarg1, void * jarg2) {
98472   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98473   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
98474
98475   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98476   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
98477   {
98478     try {
98479       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
98480     } catch (std::out_of_range& e) {
98481       {
98482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98483       };
98484     } catch (std::exception& e) {
98485       {
98486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98487       };
98488     } catch (Dali::DaliException e) {
98489       {
98490         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98491       };
98492     } catch (...) {
98493       {
98494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98495       };
98496     }
98497   }
98498
98499 }
98500
98501
98502 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Emit(void * jarg1, void * jarg2) {
98503   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98504   Dali::Toolkit::Control arg2 ;
98505   Dali::Toolkit::Control *argp2 ;
98506
98507   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98508   argp2 = (Dali::Toolkit::Control *)jarg2;
98509   if (!argp2) {
98510     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
98511     return ;
98512   }
98513   arg2 = *argp2;
98514   {
98515     try {
98516       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
98517     } catch (std::out_of_range& e) {
98518       {
98519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98520       };
98521     } catch (std::exception& e) {
98522       {
98523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98524       };
98525     } catch (Dali::DaliException e) {
98526       {
98527         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98528       };
98529     } catch (...) {
98530       {
98531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98532       };
98533     }
98534   }
98535
98536 }
98537
98538
98539 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusSignal() {
98540   void * jresult ;
98541   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
98542
98543   {
98544     try {
98545       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
98546     } catch (std::out_of_range& e) {
98547       {
98548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98549       };
98550     } catch (std::exception& e) {
98551       {
98552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98553       };
98554     } catch (Dali::DaliException e) {
98555       {
98556         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98557       };
98558     } catch (...) {
98559       {
98560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98561       };
98562     }
98563   }
98564
98565   jresult = (void *)result;
98566   return jresult;
98567 }
98568
98569
98570 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusSignal(void * jarg1) {
98571   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98572
98573   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98574   {
98575     try {
98576       delete arg1;
98577     } catch (std::out_of_range& e) {
98578       {
98579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98580       };
98581     } catch (std::exception& e) {
98582       {
98583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98584       };
98585     } catch (Dali::DaliException e) {
98586       {
98587         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98588       };
98589     } catch (...) {
98590       {
98591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98592       };
98593     }
98594   }
98595
98596 }
98597
98598
98599 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VideoViewSignal_Empty(void * jarg1) {
98600   unsigned int jresult ;
98601   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
98602   bool result;
98603
98604   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
98605   {
98606     try {
98607       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
98608     } catch (std::out_of_range& e) {
98609       {
98610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98611       };
98612     } catch (std::exception& e) {
98613       {
98614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98615       };
98616     } catch (Dali::DaliException e) {
98617       {
98618         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98619       };
98620     } catch (...) {
98621       {
98622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98623       };
98624     }
98625   }
98626
98627   jresult = result;
98628   return jresult;
98629 }
98630
98631
98632 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VideoViewSignal_GetConnectionCount(void * jarg1) {
98633   unsigned long jresult ;
98634   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
98635   std::size_t result;
98636
98637   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
98638   {
98639     try {
98640       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
98641     } catch (std::out_of_range& e) {
98642       {
98643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98644       };
98645     } catch (std::exception& e) {
98646       {
98647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98648       };
98649     } catch (Dali::DaliException e) {
98650       {
98651         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98652       };
98653     } catch (...) {
98654       {
98655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98656       };
98657     }
98658   }
98659
98660   jresult = (unsigned long)result;
98661   return jresult;
98662 }
98663
98664
98665 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Connect(void * jarg1, void * jarg2) {
98666   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
98667   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
98668
98669   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
98670   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
98671   {
98672     try {
98673       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Connect(arg1,arg2);
98674     } catch (std::out_of_range& e) {
98675       {
98676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98677       };
98678     } catch (std::exception& e) {
98679       {
98680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98681       };
98682     } catch (Dali::DaliException e) {
98683       {
98684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98685       };
98686     } catch (...) {
98687       {
98688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98689       };
98690     }
98691   }
98692
98693 }
98694
98695
98696 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Disconnect(void * jarg1, void * jarg2) {
98697   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
98698   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
98699
98700   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
98701   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
98702   {
98703     try {
98704       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Disconnect(arg1,arg2);
98705     } catch (std::out_of_range& e) {
98706       {
98707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98708       };
98709     } catch (std::exception& e) {
98710       {
98711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98712       };
98713     } catch (Dali::DaliException e) {
98714       {
98715         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98716       };
98717     } catch (...) {
98718       {
98719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98720       };
98721     }
98722   }
98723
98724 }
98725
98726
98727 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Emit(void * jarg1, void * jarg2) {
98728   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
98729   Dali::Toolkit::VideoView *arg2 = 0 ;
98730
98731   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
98732   arg2 = (Dali::Toolkit::VideoView *)jarg2;
98733   if (!arg2) {
98734     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView & type is null", 0);
98735     return ;
98736   }
98737   {
98738     try {
98739       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Emit(arg1,*arg2);
98740     } catch (std::out_of_range& e) {
98741       {
98742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98743       };
98744     } catch (std::exception& e) {
98745       {
98746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98747       };
98748     } catch (Dali::DaliException e) {
98749       {
98750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98751       };
98752     } catch (...) {
98753       {
98754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98755       };
98756     }
98757   }
98758
98759 }
98760
98761
98762 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoViewSignal() {
98763   void * jresult ;
98764   Dali::Signal< void (Dali::Toolkit::VideoView &) > *result = 0 ;
98765
98766   {
98767     try {
98768       result = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)new Dali::Signal< void (Dali::Toolkit::VideoView &) >();
98769     } catch (std::out_of_range& e) {
98770       {
98771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98772       };
98773     } catch (std::exception& e) {
98774       {
98775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98776       };
98777     } catch (Dali::DaliException e) {
98778       {
98779         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98780       };
98781     } catch (...) {
98782       {
98783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98784       };
98785     }
98786   }
98787
98788   jresult = (void *)result;
98789   return jresult;
98790 }
98791
98792
98793 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoViewSignal(void * jarg1) {
98794   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
98795
98796   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
98797   {
98798     try {
98799       delete arg1;
98800     } catch (std::out_of_range& e) {
98801       {
98802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98803       };
98804     } catch (std::exception& e) {
98805       {
98806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98807       };
98808     } catch (Dali::DaliException e) {
98809       {
98810         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98811       };
98812     } catch (...) {
98813       {
98814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98815       };
98816     }
98817   }
98818
98819 }
98820
98821
98822 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Empty(void * jarg1) {
98823   unsigned int jresult ;
98824   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
98825   bool result;
98826
98827   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
98828   {
98829     try {
98830       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
98831     } catch (std::out_of_range& e) {
98832       {
98833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98834       };
98835     } catch (std::exception& e) {
98836       {
98837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98838       };
98839     } catch (Dali::DaliException e) {
98840       {
98841         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98842       };
98843     } catch (...) {
98844       {
98845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98846       };
98847     }
98848   }
98849
98850   jresult = result;
98851   return jresult;
98852 }
98853
98854
98855 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_GetConnectionCount(void * jarg1) {
98856   unsigned long jresult ;
98857   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
98858   std::size_t result;
98859
98860   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
98861   {
98862     try {
98863       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
98864     } catch (std::out_of_range& e) {
98865       {
98866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98867       };
98868     } catch (std::exception& e) {
98869       {
98870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98871       };
98872     } catch (Dali::DaliException e) {
98873       {
98874         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98875       };
98876     } catch (...) {
98877       {
98878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98879       };
98880     }
98881   }
98882
98883   jresult = (unsigned long)result;
98884   return jresult;
98885 }
98886
98887
98888 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Connect(void * jarg1, void * jarg2) {
98889   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
98890   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
98891
98892   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
98893   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
98894   {
98895     try {
98896       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Connect(arg1,arg2);
98897     } catch (std::out_of_range& e) {
98898       {
98899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98900       };
98901     } catch (std::exception& e) {
98902       {
98903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98904       };
98905     } catch (Dali::DaliException e) {
98906       {
98907         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98908       };
98909     } catch (...) {
98910       {
98911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98912       };
98913     }
98914   }
98915
98916 }
98917
98918
98919 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
98920   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
98921   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
98922
98923   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
98924   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
98925   {
98926     try {
98927       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Disconnect(arg1,arg2);
98928     } catch (std::out_of_range& e) {
98929       {
98930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98931       };
98932     } catch (std::exception& e) {
98933       {
98934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98935       };
98936     } catch (Dali::DaliException e) {
98937       {
98938         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98939       };
98940     } catch (...) {
98941       {
98942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98943       };
98944     }
98945   }
98946
98947 }
98948
98949
98950 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3) {
98951   unsigned int jresult ;
98952   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
98953   Dali::Toolkit::Slider arg2 ;
98954   float arg3 ;
98955   Dali::Toolkit::Slider *argp2 ;
98956   bool result;
98957
98958   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
98959   argp2 = (Dali::Toolkit::Slider *)jarg2;
98960   if (!argp2) {
98961     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
98962     return 0;
98963   }
98964   arg2 = *argp2;
98965   arg3 = (float)jarg3;
98966   {
98967     try {
98968       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Emit(arg1,arg2,arg3);
98969     } catch (std::out_of_range& e) {
98970       {
98971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98972       };
98973     } catch (std::exception& e) {
98974       {
98975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98976       };
98977     } catch (Dali::DaliException e) {
98978       {
98979         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98980       };
98981     } catch (...) {
98982       {
98983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98984       };
98985     }
98986   }
98987
98988   jresult = result;
98989   return jresult;
98990 }
98991
98992
98993 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderValueChangedSignal() {
98994   void * jresult ;
98995   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *result = 0 ;
98996
98997   {
98998     try {
98999       result = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,float) >();
99000     } catch (std::out_of_range& e) {
99001       {
99002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99003       };
99004     } catch (std::exception& e) {
99005       {
99006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99007       };
99008     } catch (Dali::DaliException e) {
99009       {
99010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99011       };
99012     } catch (...) {
99013       {
99014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99015       };
99016     }
99017   }
99018
99019   jresult = (void *)result;
99020   return jresult;
99021 }
99022
99023
99024 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderValueChangedSignal(void * jarg1) {
99025   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
99026
99027   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
99028   {
99029     try {
99030       delete arg1;
99031     } catch (std::out_of_range& e) {
99032       {
99033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99034       };
99035     } catch (std::exception& e) {
99036       {
99037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99038       };
99039     } catch (Dali::DaliException e) {
99040       {
99041         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99042       };
99043     } catch (...) {
99044       {
99045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99046       };
99047     }
99048   }
99049
99050 }
99051
99052
99053 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Empty(void * jarg1) {
99054   unsigned int jresult ;
99055   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
99056   bool result;
99057
99058   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
99059   {
99060     try {
99061       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
99062     } catch (std::out_of_range& e) {
99063       {
99064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99065       };
99066     } catch (std::exception& e) {
99067       {
99068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99069       };
99070     } catch (Dali::DaliException e) {
99071       {
99072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99073       };
99074     } catch (...) {
99075       {
99076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99077       };
99078     }
99079   }
99080
99081   jresult = result;
99082   return jresult;
99083 }
99084
99085
99086 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_GetConnectionCount(void * jarg1) {
99087   unsigned long jresult ;
99088   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
99089   std::size_t result;
99090
99091   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
99092   {
99093     try {
99094       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
99095     } catch (std::out_of_range& e) {
99096       {
99097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99098       };
99099     } catch (std::exception& e) {
99100       {
99101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99102       };
99103     } catch (Dali::DaliException e) {
99104       {
99105         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99106       };
99107     } catch (...) {
99108       {
99109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99110       };
99111     }
99112   }
99113
99114   jresult = (unsigned long)result;
99115   return jresult;
99116 }
99117
99118
99119 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Connect(void * jarg1, void * jarg2) {
99120   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
99121   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
99122
99123   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
99124   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
99125   {
99126     try {
99127       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Connect(arg1,arg2);
99128     } catch (std::out_of_range& e) {
99129       {
99130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99131       };
99132     } catch (std::exception& e) {
99133       {
99134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99135       };
99136     } catch (Dali::DaliException e) {
99137       {
99138         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99139       };
99140     } catch (...) {
99141       {
99142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99143       };
99144     }
99145   }
99146
99147 }
99148
99149
99150 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Disconnect(void * jarg1, void * jarg2) {
99151   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
99152   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
99153
99154   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
99155   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
99156   {
99157     try {
99158       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Disconnect(arg1,arg2);
99159     } catch (std::out_of_range& e) {
99160       {
99161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99162       };
99163     } catch (std::exception& e) {
99164       {
99165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99166       };
99167     } catch (Dali::DaliException e) {
99168       {
99169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99170       };
99171     } catch (...) {
99172       {
99173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99174       };
99175     }
99176   }
99177
99178 }
99179
99180
99181 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
99182   unsigned int jresult ;
99183   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
99184   Dali::Toolkit::Slider arg2 ;
99185   int arg3 ;
99186   Dali::Toolkit::Slider *argp2 ;
99187   bool result;
99188
99189   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
99190   argp2 = (Dali::Toolkit::Slider *)jarg2;
99191   if (!argp2) {
99192     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
99193     return 0;
99194   }
99195   arg2 = *argp2;
99196   arg3 = (int)jarg3;
99197   {
99198     try {
99199       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Emit(arg1,arg2,arg3);
99200     } catch (std::out_of_range& e) {
99201       {
99202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99203       };
99204     } catch (std::exception& e) {
99205       {
99206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99207       };
99208     } catch (Dali::DaliException e) {
99209       {
99210         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99211       };
99212     } catch (...) {
99213       {
99214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99215       };
99216     }
99217   }
99218
99219   jresult = result;
99220   return jresult;
99221 }
99222
99223
99224 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderMarkReachedSignal() {
99225   void * jresult ;
99226   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *result = 0 ;
99227
99228   {
99229     try {
99230       result = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,int) >();
99231     } catch (std::out_of_range& e) {
99232       {
99233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99234       };
99235     } catch (std::exception& e) {
99236       {
99237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99238       };
99239     } catch (Dali::DaliException e) {
99240       {
99241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99242       };
99243     } catch (...) {
99244       {
99245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99246       };
99247     }
99248   }
99249
99250   jresult = (void *)result;
99251   return jresult;
99252 }
99253
99254
99255 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderMarkReachedSignal(void * jarg1) {
99256   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
99257
99258   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
99259   {
99260     try {
99261       delete arg1;
99262     } catch (std::out_of_range& e) {
99263       {
99264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99265       };
99266     } catch (std::exception& e) {
99267       {
99268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99269       };
99270     } catch (Dali::DaliException e) {
99271       {
99272         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99273       };
99274     } catch (...) {
99275       {
99276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99277       };
99278     }
99279   }
99280
99281 }
99282
99283
99284 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_0() {
99285   void * jresult ;
99286   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
99287
99288   {
99289     try {
99290       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >();
99291     } catch (std::out_of_range& e) {
99292       {
99293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99294       };
99295     } catch (std::exception& e) {
99296       {
99297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99298       };
99299     } catch (Dali::DaliException e) {
99300       {
99301         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99302       };
99303     } catch (...) {
99304       {
99305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99306       };
99307     }
99308   }
99309
99310   jresult = (void *)result;
99311   return jresult;
99312 }
99313
99314
99315 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_1(void * jarg1) {
99316   void * jresult ;
99317   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
99318   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
99319
99320   arg1 = (Dali::Toolkit::Ruler *)jarg1;
99321   {
99322     try {
99323       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >(arg1);
99324     } catch (std::out_of_range& e) {
99325       {
99326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99327       };
99328     } catch (std::exception& e) {
99329       {
99330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99331       };
99332     } catch (Dali::DaliException e) {
99333       {
99334         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99335       };
99336     } catch (...) {
99337       {
99338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99339       };
99340     }
99341   }
99342
99343   jresult = (void *)result;
99344   return jresult;
99345 }
99346
99347
99348 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_2(void * jarg1) {
99349   void * jresult ;
99350   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = 0 ;
99351   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
99352
99353   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99354   if (!arg1) {
99355     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
99356     return 0;
99357   }
99358   {
99359     try {
99360       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg1);
99361     } catch (std::out_of_range& e) {
99362       {
99363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99364       };
99365     } catch (std::exception& e) {
99366       {
99367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99368       };
99369     } catch (Dali::DaliException e) {
99370       {
99371         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99372       };
99373     } catch (...) {
99374       {
99375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99376       };
99377     }
99378   }
99379
99380   jresult = (void *)result;
99381   return jresult;
99382 }
99383
99384
99385 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerPtr(void * jarg1) {
99386   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99387
99388   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99389   {
99390     try {
99391       delete arg1;
99392     } catch (std::out_of_range& e) {
99393       {
99394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99395       };
99396     } catch (std::exception& e) {
99397       {
99398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99399       };
99400     } catch (Dali::DaliException e) {
99401       {
99402         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99403       };
99404     } catch (...) {
99405       {
99406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99407       };
99408     }
99409   }
99410
99411 }
99412
99413
99414 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Get(void * jarg1) {
99415   void * jresult ;
99416   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99417   Dali::Toolkit::Ruler *result = 0 ;
99418
99419   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99420   {
99421     try {
99422       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->Get();
99423     } catch (std::out_of_range& e) {
99424       {
99425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99426       };
99427     } catch (std::exception& e) {
99428       {
99429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99430       };
99431     } catch (Dali::DaliException e) {
99432       {
99433         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99434       };
99435     } catch (...) {
99436       {
99437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99438       };
99439     }
99440   }
99441
99442   jresult = (void *)result;
99443   return jresult;
99444 }
99445
99446
99447 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___deref__(void * jarg1) {
99448   void * jresult ;
99449   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99450   Dali::Toolkit::Ruler *result = 0 ;
99451
99452   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99453   {
99454     try {
99455       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator ->();
99456     } catch (std::out_of_range& e) {
99457       {
99458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99459       };
99460     } catch (std::exception& e) {
99461       {
99462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99463       };
99464     } catch (Dali::DaliException e) {
99465       {
99466         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99467       };
99468     } catch (...) {
99469       {
99470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99471       };
99472     }
99473   }
99474
99475   jresult = (void *)result;
99476   return jresult;
99477 }
99478
99479
99480 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___ref__(void * jarg1) {
99481   void * jresult ;
99482   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99483   Dali::Toolkit::Ruler *result = 0 ;
99484
99485   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99486   {
99487     try {
99488       result = (Dali::Toolkit::Ruler *) &((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator *();
99489     } catch (std::out_of_range& e) {
99490       {
99491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99492       };
99493     } catch (std::exception& e) {
99494       {
99495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99496       };
99497     } catch (Dali::DaliException e) {
99498       {
99499         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99500       };
99501     } catch (...) {
99502       {
99503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99504       };
99505     }
99506   }
99507
99508   jresult = (void *)result;
99509   return jresult;
99510 }
99511
99512
99513 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_0(void * jarg1, void * jarg2) {
99514   void * jresult ;
99515   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99516   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg2 = 0 ;
99517   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
99518
99519   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99520   arg2 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg2;
99521   if (!arg2) {
99522     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
99523     return 0;
99524   }
99525   {
99526     try {
99527       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg2);
99528     } catch (std::out_of_range& e) {
99529       {
99530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99531       };
99532     } catch (std::exception& e) {
99533       {
99534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99535       };
99536     } catch (Dali::DaliException e) {
99537       {
99538         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99539       };
99540     } catch (...) {
99541       {
99542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99543       };
99544     }
99545   }
99546
99547   jresult = (void *)result;
99548   return jresult;
99549 }
99550
99551
99552 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_1(void * jarg1, void * jarg2) {
99553   void * jresult ;
99554   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99555   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
99556   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
99557
99558   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99559   arg2 = (Dali::Toolkit::Ruler *)jarg2;
99560   {
99561     try {
99562       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =(arg2);
99563     } catch (std::out_of_range& e) {
99564       {
99565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99566       };
99567     } catch (std::exception& e) {
99568       {
99569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99570       };
99571     } catch (Dali::DaliException e) {
99572       {
99573         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99574       };
99575     } catch (...) {
99576       {
99577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99578       };
99579     }
99580   }
99581
99582   jresult = (void *)result;
99583   return jresult;
99584 }
99585
99586
99587 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_0(void * jarg1) {
99588   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99589
99590   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99591   {
99592     try {
99593       (arg1)->Reset();
99594     } catch (std::out_of_range& e) {
99595       {
99596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99597       };
99598     } catch (std::exception& e) {
99599       {
99600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99601       };
99602     } catch (Dali::DaliException e) {
99603       {
99604         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99605       };
99606     } catch (...) {
99607       {
99608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99609       };
99610     }
99611   }
99612
99613 }
99614
99615
99616 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_1(void * jarg1, void * jarg2) {
99617   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99618   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
99619
99620   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99621   arg2 = (Dali::Toolkit::Ruler *)jarg2;
99622   {
99623     try {
99624       (arg1)->Reset(arg2);
99625     } catch (std::out_of_range& e) {
99626       {
99627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99628       };
99629     } catch (std::exception& e) {
99630       {
99631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99632       };
99633     } catch (Dali::DaliException e) {
99634       {
99635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99636       };
99637     } catch (...) {
99638       {
99639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99640       };
99641     }
99642   }
99643
99644 }
99645
99646
99647 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Detach(void * jarg1) {
99648   void * jresult ;
99649   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99650   Dali::Toolkit::Ruler *result = 0 ;
99651
99652   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99653   {
99654     try {
99655       result = (Dali::Toolkit::Ruler *)(arg1)->Detach();
99656     } catch (std::out_of_range& e) {
99657       {
99658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99659       };
99660     } catch (std::exception& e) {
99661       {
99662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99663       };
99664     } catch (Dali::DaliException e) {
99665       {
99666         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99667       };
99668     } catch (...) {
99669       {
99670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99671       };
99672     }
99673   }
99674
99675   jresult = (void *)result;
99676   return jresult;
99677 }
99678
99679
99680 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
99681   float jresult ;
99682   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99683   float arg2 ;
99684   float arg3 ;
99685   float result;
99686
99687   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99688   arg2 = (float)jarg2;
99689   arg3 = (float)jarg3;
99690   {
99691     try {
99692       result = (float)(*arg1)->Snap(arg2,arg3);
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 float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_1(void * jarg1, float jarg2) {
99718   float jresult ;
99719   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99720   float arg2 ;
99721   float result;
99722
99723   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99724   arg2 = (float)jarg2;
99725   {
99726     try {
99727       result = (float)(*arg1)->Snap(arg2);
99728     } catch (std::out_of_range& e) {
99729       {
99730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99731       };
99732     } catch (std::exception& e) {
99733       {
99734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99735       };
99736     } catch (Dali::DaliException e) {
99737       {
99738         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99739       };
99740     } catch (...) {
99741       {
99742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99743       };
99744     }
99745   }
99746
99747   jresult = result;
99748   return jresult;
99749 }
99750
99751
99752 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
99753   float jresult ;
99754   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99755   unsigned int arg2 ;
99756   unsigned int *arg3 = 0 ;
99757   bool arg4 ;
99758   float result;
99759
99760   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99761   arg2 = (unsigned int)jarg2;
99762   arg3 = (unsigned int *)jarg3;
99763   arg4 = jarg4 ? true : false;
99764   {
99765     try {
99766       result = (float)(*arg1)->GetPositionFromPage(arg2,*arg3,arg4);
99767     } catch (std::out_of_range& e) {
99768       {
99769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99770       };
99771     } catch (std::exception& e) {
99772       {
99773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99774       };
99775     } catch (Dali::DaliException e) {
99776       {
99777         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99778       };
99779     } catch (...) {
99780       {
99781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99782       };
99783     }
99784   }
99785
99786   jresult = result;
99787   return jresult;
99788 }
99789
99790
99791 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
99792   unsigned int jresult ;
99793   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99794   float arg2 ;
99795   bool arg3 ;
99796   unsigned int result;
99797
99798   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99799   arg2 = (float)jarg2;
99800   arg3 = jarg3 ? true : false;
99801   {
99802     try {
99803       result = (unsigned int)(*arg1)->GetPageFromPosition(arg2,arg3);
99804     } catch (std::out_of_range& e) {
99805       {
99806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99807       };
99808     } catch (std::exception& e) {
99809       {
99810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99811       };
99812     } catch (Dali::DaliException e) {
99813       {
99814         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99815       };
99816     } catch (...) {
99817       {
99818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99819       };
99820     }
99821   }
99822
99823   jresult = result;
99824   return jresult;
99825 }
99826
99827
99828 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetTotalPages(void * jarg1) {
99829   unsigned int jresult ;
99830   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99831   unsigned int result;
99832
99833   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99834   {
99835     try {
99836       result = (unsigned int)(*arg1)->GetTotalPages();
99837     } catch (std::out_of_range& e) {
99838       {
99839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99840       };
99841     } catch (std::exception& e) {
99842       {
99843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99844       };
99845     } catch (Dali::DaliException e) {
99846       {
99847         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99848       };
99849     } catch (...) {
99850       {
99851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99852       };
99853     }
99854   }
99855
99856   jresult = result;
99857   return jresult;
99858 }
99859
99860
99861 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_GetType(void * jarg1) {
99862   int jresult ;
99863   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99864   Dali::Toolkit::Ruler::RulerType result;
99865
99866   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99867   {
99868     try {
99869       result = (Dali::Toolkit::Ruler::RulerType)(*arg1)->GetType();
99870     } catch (std::out_of_range& e) {
99871       {
99872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99873       };
99874     } catch (std::exception& e) {
99875       {
99876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99877       };
99878     } catch (Dali::DaliException e) {
99879       {
99880         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99881       };
99882     } catch (...) {
99883       {
99884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99885       };
99886     }
99887   }
99888
99889   jresult = (int)result;
99890   return jresult;
99891 }
99892
99893
99894 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_IsEnabled(void * jarg1) {
99895   unsigned int jresult ;
99896   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99897   bool result;
99898
99899   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99900   {
99901     try {
99902       result = (bool)(*arg1)->IsEnabled();
99903     } catch (std::out_of_range& e) {
99904       {
99905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99906       };
99907     } catch (std::exception& e) {
99908       {
99909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99910       };
99911     } catch (Dali::DaliException e) {
99912       {
99913         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99914       };
99915     } catch (...) {
99916       {
99917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99918       };
99919     }
99920   }
99921
99922   jresult = result;
99923   return jresult;
99924 }
99925
99926
99927 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Enable(void * jarg1) {
99928   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99929
99930   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99931   {
99932     try {
99933       (*arg1)->Enable();
99934     } catch (std::out_of_range& e) {
99935       {
99936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99937       };
99938     } catch (std::exception& e) {
99939       {
99940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99941       };
99942     } catch (Dali::DaliException e) {
99943       {
99944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99945       };
99946     } catch (...) {
99947       {
99948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99949       };
99950     }
99951   }
99952
99953 }
99954
99955
99956 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Disable(void * jarg1) {
99957   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99958
99959   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99960   {
99961     try {
99962       (*arg1)->Disable();
99963     } catch (std::out_of_range& e) {
99964       {
99965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99966       };
99967     } catch (std::exception& e) {
99968       {
99969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99970       };
99971     } catch (Dali::DaliException e) {
99972       {
99973         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99974       };
99975     } catch (...) {
99976       {
99977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99978       };
99979     }
99980   }
99981
99982 }
99983
99984
99985 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_SetDomain(void * jarg1, void * jarg2) {
99986   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99987   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
99988   Dali::Toolkit::RulerDomain *argp2 ;
99989
99990   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99991   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
99992   if (!argp2) {
99993     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
99994     return ;
99995   }
99996   arg2 = *argp2;
99997   {
99998     try {
99999       (*arg1)->SetDomain(arg2);
100000     } catch (std::out_of_range& e) {
100001       {
100002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100003       };
100004     } catch (std::exception& e) {
100005       {
100006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100007       };
100008     } catch (Dali::DaliException e) {
100009       {
100010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100011       };
100012     } catch (...) {
100013       {
100014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100015       };
100016     }
100017   }
100018
100019 }
100020
100021
100022 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_GetDomain(void * jarg1) {
100023   void * jresult ;
100024   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100025   Dali::Toolkit::RulerDomain *result = 0 ;
100026
100027   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100028   {
100029     try {
100030       result = (Dali::Toolkit::RulerDomain *) &(*arg1)->GetDomain();
100031     } catch (std::out_of_range& e) {
100032       {
100033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100034       };
100035     } catch (std::exception& e) {
100036       {
100037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100038       };
100039     } catch (Dali::DaliException e) {
100040       {
100041         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100042       };
100043     } catch (...) {
100044       {
100045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100046       };
100047     }
100048   }
100049
100050   jresult = (void *)result;
100051   return jresult;
100052 }
100053
100054
100055 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_DisableDomain(void * jarg1) {
100056   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100057
100058   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100059   {
100060     try {
100061       (*arg1)->DisableDomain();
100062     } catch (std::out_of_range& e) {
100063       {
100064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100065       };
100066     } catch (std::exception& e) {
100067       {
100068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100069       };
100070     } catch (Dali::DaliException e) {
100071       {
100072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100073       };
100074     } catch (...) {
100075       {
100076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100077       };
100078     }
100079   }
100080
100081 }
100082
100083
100084 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
100085   float jresult ;
100086   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100087   float arg2 ;
100088   float arg3 ;
100089   float arg4 ;
100090   float result;
100091
100092   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100093   arg2 = (float)jarg2;
100094   arg3 = (float)jarg3;
100095   arg4 = (float)jarg4;
100096   {
100097     try {
100098       result = (float)(*arg1)->Clamp(arg2,arg3,arg4);
100099     } catch (std::out_of_range& e) {
100100       {
100101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100102       };
100103     } catch (std::exception& e) {
100104       {
100105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100106       };
100107     } catch (Dali::DaliException e) {
100108       {
100109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100110       };
100111     } catch (...) {
100112       {
100113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100114       };
100115     }
100116   }
100117
100118   jresult = result;
100119   return jresult;
100120 }
100121
100122
100123 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
100124   float jresult ;
100125   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100126   float arg2 ;
100127   float arg3 ;
100128   float result;
100129
100130   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100131   arg2 = (float)jarg2;
100132   arg3 = (float)jarg3;
100133   {
100134     try {
100135       result = (float)(*arg1)->Clamp(arg2,arg3);
100136     } catch (std::out_of_range& e) {
100137       {
100138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100139       };
100140     } catch (std::exception& e) {
100141       {
100142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100143       };
100144     } catch (Dali::DaliException e) {
100145       {
100146         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100147       };
100148     } catch (...) {
100149       {
100150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100151       };
100152     }
100153   }
100154
100155   jresult = result;
100156   return jresult;
100157 }
100158
100159
100160 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_2(void * jarg1, float jarg2) {
100161   float jresult ;
100162   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100163   float arg2 ;
100164   float result;
100165
100166   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100167   arg2 = (float)jarg2;
100168   {
100169     try {
100170       result = (float)(*arg1)->Clamp(arg2);
100171     } catch (std::out_of_range& e) {
100172       {
100173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100174       };
100175     } catch (std::exception& e) {
100176       {
100177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100178       };
100179     } catch (Dali::DaliException e) {
100180       {
100181         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100182       };
100183     } catch (...) {
100184       {
100185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100186       };
100187     }
100188   }
100189
100190   jresult = result;
100191   return jresult;
100192 }
100193
100194
100195 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
100196   float jresult ;
100197   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100198   float arg2 ;
100199   float arg3 ;
100200   float arg4 ;
100201   Dali::Toolkit::ClampState *arg5 = 0 ;
100202   float result;
100203
100204   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100205   arg2 = (float)jarg2;
100206   arg3 = (float)jarg3;
100207   arg4 = (float)jarg4;
100208   arg5 = (Dali::Toolkit::ClampState *)jarg5;
100209   if (!arg5) {
100210     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
100211     return 0;
100212   }
100213   {
100214     try {
100215       result = (float)(*arg1)->Clamp(arg2,arg3,arg4,*arg5);
100216     } catch (std::out_of_range& e) {
100217       {
100218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100219       };
100220     } catch (std::exception& e) {
100221       {
100222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100223       };
100224     } catch (Dali::DaliException e) {
100225       {
100226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100227       };
100228     } catch (...) {
100229       {
100230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100231       };
100232     }
100233   }
100234
100235   jresult = result;
100236   return jresult;
100237 }
100238
100239
100240 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
100241   float jresult ;
100242   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100243   float arg2 ;
100244   float arg3 ;
100245   float arg4 ;
100246   float arg5 ;
100247   float result;
100248
100249   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100250   arg2 = (float)jarg2;
100251   arg3 = (float)jarg3;
100252   arg4 = (float)jarg4;
100253   arg5 = (float)jarg5;
100254   {
100255     try {
100256       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
100257     } catch (std::out_of_range& e) {
100258       {
100259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100260       };
100261     } catch (std::exception& e) {
100262       {
100263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100264       };
100265     } catch (Dali::DaliException e) {
100266       {
100267         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100268       };
100269     } catch (...) {
100270       {
100271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100272       };
100273     }
100274   }
100275
100276   jresult = result;
100277   return jresult;
100278 }
100279
100280
100281 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
100282   float jresult ;
100283   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100284   float arg2 ;
100285   float arg3 ;
100286   float arg4 ;
100287   float result;
100288
100289   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100290   arg2 = (float)jarg2;
100291   arg3 = (float)jarg3;
100292   arg4 = (float)jarg4;
100293   {
100294     try {
100295       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4);
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 float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
100321   float jresult ;
100322   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100323   float arg2 ;
100324   float arg3 ;
100325   float result;
100326
100327   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100328   arg2 = (float)jarg2;
100329   arg3 = (float)jarg3;
100330   {
100331     try {
100332       result = (float)(*arg1)->SnapAndClamp(arg2,arg3);
100333     } catch (std::out_of_range& e) {
100334       {
100335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100336       };
100337     } catch (std::exception& e) {
100338       {
100339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100340       };
100341     } catch (Dali::DaliException e) {
100342       {
100343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100344       };
100345     } catch (...) {
100346       {
100347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100348       };
100349     }
100350   }
100351
100352   jresult = result;
100353   return jresult;
100354 }
100355
100356
100357 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
100358   float jresult ;
100359   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100360   float arg2 ;
100361   float result;
100362
100363   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100364   arg2 = (float)jarg2;
100365   {
100366     try {
100367       result = (float)(*arg1)->SnapAndClamp(arg2);
100368     } catch (std::out_of_range& e) {
100369       {
100370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100371       };
100372     } catch (std::exception& e) {
100373       {
100374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100375       };
100376     } catch (Dali::DaliException e) {
100377       {
100378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100379       };
100380     } catch (...) {
100381       {
100382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100383       };
100384     }
100385   }
100386
100387   jresult = result;
100388   return jresult;
100389 }
100390
100391
100392 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
100393   float jresult ;
100394   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100395   float arg2 ;
100396   float arg3 ;
100397   float arg4 ;
100398   float arg5 ;
100399   Dali::Toolkit::ClampState *arg6 = 0 ;
100400   float result;
100401
100402   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100403   arg2 = (float)jarg2;
100404   arg3 = (float)jarg3;
100405   arg4 = (float)jarg4;
100406   arg5 = (float)jarg5;
100407   arg6 = (Dali::Toolkit::ClampState *)jarg6;
100408   if (!arg6) {
100409     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
100410     return 0;
100411   }
100412   {
100413     try {
100414       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
100415     } catch (std::out_of_range& e) {
100416       {
100417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100418       };
100419     } catch (std::exception& e) {
100420       {
100421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100422       };
100423     } catch (Dali::DaliException e) {
100424       {
100425         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100426       };
100427     } catch (...) {
100428       {
100429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100430       };
100431     }
100432   }
100433
100434   jresult = result;
100435   return jresult;
100436 }
100437
100438
100439 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reference(void * jarg1) {
100440   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100441
100442   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100443   {
100444     try {
100445       (*arg1)->Reference();
100446     } catch (std::out_of_range& e) {
100447       {
100448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100449       };
100450     } catch (std::exception& e) {
100451       {
100452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100453       };
100454     } catch (Dali::DaliException e) {
100455       {
100456         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100457       };
100458     } catch (...) {
100459       {
100460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100461       };
100462     }
100463   }
100464
100465 }
100466
100467
100468 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Unreference(void * jarg1) {
100469   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100470
100471   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100472   {
100473     try {
100474       (*arg1)->Unreference();
100475     } catch (std::out_of_range& e) {
100476       {
100477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100478       };
100479     } catch (std::exception& e) {
100480       {
100481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100482       };
100483     } catch (Dali::DaliException e) {
100484       {
100485         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100486       };
100487     } catch (...) {
100488       {
100489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100490       };
100491     }
100492   }
100493
100494 }
100495
100496
100497 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_ReferenceCount(void * jarg1) {
100498   int jresult ;
100499   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100500   int result;
100501
100502   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100503   {
100504     try {
100505       result = (int)(*arg1)->ReferenceCount();
100506     } catch (std::out_of_range& e) {
100507       {
100508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100509       };
100510     } catch (std::exception& e) {
100511       {
100512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100513       };
100514     } catch (Dali::DaliException e) {
100515       {
100516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100517       };
100518     } catch (...) {
100519       {
100520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100521       };
100522     }
100523   }
100524
100525   jresult = result;
100526   return jresult;
100527 }
100528
100529
100530 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Empty(void * jarg1) {
100531   unsigned int jresult ;
100532   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100533   bool result;
100534
100535   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100536   {
100537     try {
100538       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
100539     } catch (std::out_of_range& e) {
100540       {
100541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100542       };
100543     } catch (std::exception& e) {
100544       {
100545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100546       };
100547     } catch (Dali::DaliException e) {
100548       {
100549         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100550       };
100551     } catch (...) {
100552       {
100553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100554       };
100555     }
100556   }
100557
100558   jresult = result;
100559   return jresult;
100560 }
100561
100562
100563 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_GetConnectionCount(void * jarg1) {
100564   unsigned long jresult ;
100565   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100566   std::size_t result;
100567
100568   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100569   {
100570     try {
100571       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
100572     } catch (std::out_of_range& e) {
100573       {
100574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100575       };
100576     } catch (std::exception& e) {
100577       {
100578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100579       };
100580     } catch (Dali::DaliException e) {
100581       {
100582         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100583       };
100584     } catch (...) {
100585       {
100586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100587       };
100588     }
100589   }
100590
100591   jresult = (unsigned long)result;
100592   return jresult;
100593 }
100594
100595
100596 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Connect(void * jarg1, void * jarg2) {
100597   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100598   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
100599
100600   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100601   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
100602   {
100603     try {
100604       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
100605     } catch (std::out_of_range& e) {
100606       {
100607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100608       };
100609     } catch (std::exception& e) {
100610       {
100611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100612       };
100613     } catch (Dali::DaliException e) {
100614       {
100615         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100616       };
100617     } catch (...) {
100618       {
100619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100620       };
100621     }
100622   }
100623
100624 }
100625
100626
100627 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Disconnect(void * jarg1, void * jarg2) {
100628   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100629   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
100630
100631   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100632   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
100633   {
100634     try {
100635       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
100636     } catch (std::out_of_range& e) {
100637       {
100638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100639       };
100640     } catch (std::exception& e) {
100641       {
100642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100643       };
100644     } catch (Dali::DaliException e) {
100645       {
100646         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100647       };
100648     } catch (...) {
100649       {
100650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100651       };
100652     }
100653   }
100654
100655 }
100656
100657
100658 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Emit(void * jarg1, void * jarg2) {
100659   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100660   Dali::Toolkit::Control arg2 ;
100661   Dali::Toolkit::Control *argp2 ;
100662
100663   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100664   argp2 = (Dali::Toolkit::Control *)jarg2;
100665   if (!argp2) {
100666     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
100667     return ;
100668   }
100669   arg2 = *argp2;
100670   {
100671     try {
100672       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
100673     } catch (std::out_of_range& e) {
100674       {
100675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100676       };
100677     } catch (std::exception& e) {
100678       {
100679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100680       };
100681     } catch (Dali::DaliException e) {
100682       {
100683         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100684       };
100685     } catch (...) {
100686       {
100687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100688       };
100689     }
100690   }
100691
100692 }
100693
100694
100695 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewResourceReadySignal() {
100696   void * jresult ;
100697   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
100698
100699   {
100700     try {
100701       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
100702     } catch (std::out_of_range& e) {
100703       {
100704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100705       };
100706     } catch (std::exception& e) {
100707       {
100708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100709       };
100710     } catch (Dali::DaliException e) {
100711       {
100712         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100713       };
100714     } catch (...) {
100715       {
100716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100717       };
100718     }
100719   }
100720
100721   jresult = (void *)result;
100722   return jresult;
100723 }
100724
100725
100726 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewResourceReadySignal(void * jarg1) {
100727   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100728
100729   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100730   {
100731     try {
100732       delete arg1;
100733     } catch (std::out_of_range& e) {
100734       {
100735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100736       };
100737     } catch (std::exception& e) {
100738       {
100739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100740       };
100741     } catch (Dali::DaliException e) {
100742       {
100743         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100744       };
100745     } catch (...) {
100746       {
100747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100748       };
100749     }
100750   }
100751
100752 }
100753
100754 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_GetRefObjectPtr(Dali::BaseHandle *arg1) {
100755   Dali::RefObject *result = NULL;
100756
100757   if (arg1)
100758   {
100759     result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
100760   }
100761   return result;
100762 }
100763
100764 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_BaseObject_SWIGUpcast(Dali::BaseObject *jarg1) {
100765     return (Dali::RefObject *)jarg1;
100766 }
100767
100768 SWIGEXPORT Dali::SignalObserver * SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SWIGUpcast(Dali::ConnectionTrackerInterface *jarg1) {
100769     return (Dali::SignalObserver *)jarg1;
100770 }
100771
100772 SWIGEXPORT Dali::ConnectionTrackerInterface * SWIGSTDCALL CSharp_Dali_ConnectionTracker_SWIGUpcast(Dali::ConnectionTracker *jarg1) {
100773     return (Dali::ConnectionTrackerInterface *)jarg1;
100774 }
100775
100776 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ObjectRegistry_SWIGUpcast(Dali::ObjectRegistry *jarg1) {
100777     return (Dali::BaseHandle *)jarg1;
100778 }
100779
100780 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyCondition_SWIGUpcast(Dali::PropertyCondition *jarg1) {
100781     return (Dali::BaseHandle *)jarg1;
100782 }
100783
100784 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyNotification_SWIGUpcast(Dali::PropertyNotification *jarg1) {
100785     return (Dali::BaseHandle *)jarg1;
100786 }
100787
100788 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Handle_SWIGUpcast(Dali::Handle *jarg1) {
100789     return (Dali::BaseHandle *)jarg1;
100790 }
100791
100792 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeInfo_SWIGUpcast(Dali::TypeInfo *jarg1) {
100793     return (Dali::BaseHandle *)jarg1;
100794 }
100795
100796 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeRegistry_SWIGUpcast(Dali::TypeRegistry *jarg1) {
100797     return (Dali::BaseHandle *)jarg1;
100798 }
100799
100800 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Image_SWIGUpcast(Dali::Image *jarg1) {
100801     return (Dali::BaseHandle *)jarg1;
100802 }
100803
100804 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelData_SWIGUpcast(Dali::PixelData *jarg1) {
100805     return (Dali::BaseHandle *)jarg1;
100806 }
100807
100808 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Texture_SWIGUpcast(Dali::Texture *jarg1) {
100809     return (Dali::BaseHandle *)jarg1;
100810 }
100811
100812 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Sampler_SWIGUpcast(Dali::Sampler *jarg1) {
100813     return (Dali::BaseHandle *)jarg1;
100814 }
100815
100816 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TextureSet_SWIGUpcast(Dali::TextureSet *jarg1) {
100817     return (Dali::BaseHandle *)jarg1;
100818 }
100819
100820 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyBuffer_SWIGUpcast(Dali::PropertyBuffer *jarg1) {
100821     return (Dali::BaseHandle *)jarg1;
100822 }
100823
100824 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Geometry_SWIGUpcast(Dali::Geometry *jarg1) {
100825     return (Dali::BaseHandle *)jarg1;
100826 }
100827
100828 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Shader_SWIGUpcast(Dali::Shader *jarg1) {
100829     return (Dali::Handle *)jarg1;
100830 }
100831
100832 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Renderer_SWIGUpcast(Dali::Renderer *jarg1) {
100833     return (Dali::Handle *)jarg1;
100834 }
100835
100836 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_FrameBuffer_SWIGUpcast(Dali::FrameBuffer *jarg1) {
100837     return (Dali::BaseHandle *)jarg1;
100838 }
100839
100840 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_RenderTaskList_SWIGUpcast(Dali::RenderTaskList *jarg1) {
100841     return (Dali::BaseHandle *)jarg1;
100842 }
100843
100844 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_RenderTask_SWIGUpcast(Dali::RenderTask *jarg1) {
100845     return (Dali::Handle *)jarg1;
100846 }
100847
100848 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Touch_SWIGUpcast(Dali::TouchData *jarg1) {
100849     return (Dali::BaseHandle *)jarg1;
100850 }
100851
100852 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_GestureDetector_SWIGUpcast(Dali::GestureDetector *jarg1) {
100853     return (Dali::Handle *)jarg1;
100854 }
100855
100856 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SWIGUpcast(Dali::LongPressGestureDetector *jarg1) {
100857     return (Dali::GestureDetector *)jarg1;
100858 }
100859
100860 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_LongPressGesture_SWIGUpcast(Dali::LongPressGesture *jarg1) {
100861     return (Dali::Gesture *)jarg1;
100862 }
100863
100864 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Actor_SWIGUpcast(Dali::Actor *jarg1) {
100865     return (Dali::Handle *)jarg1;
100866 }
100867
100868 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_Layer_SWIGUpcast(Dali::Layer *jarg1) {
100869     return (Dali::Actor *)jarg1;
100870 }
100871
100872 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Stage_SWIGUpcast(Dali::Stage *jarg1) {
100873     return (Dali::BaseHandle *)jarg1;
100874 }
100875
100876 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_CustomActorImpl_SWIGUpcast(Dali::CustomActorImpl *jarg1) {
100877     return (Dali::RefObject *)jarg1;
100878 }
100879
100880 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CustomActor_SWIGUpcast(Dali::CustomActor *jarg1) {
100881     return (Dali::Actor *)jarg1;
100882 }
100883
100884 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PanGestureDetector_SWIGUpcast(Dali::PanGestureDetector *jarg1) {
100885     return (Dali::GestureDetector *)jarg1;
100886 }
100887
100888 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PanGesture_SWIGUpcast(Dali::PanGesture *jarg1) {
100889     return (Dali::Gesture *)jarg1;
100890 }
100891
100892 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_SWIGUpcast(Dali::PinchGestureDetector *jarg1) {
100893     return (Dali::GestureDetector *)jarg1;
100894 }
100895
100896 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PinchGesture_SWIGUpcast(Dali::PinchGesture *jarg1) {
100897     return (Dali::Gesture *)jarg1;
100898 }
100899
100900 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_TapGestureDetector_SWIGUpcast(Dali::TapGestureDetector *jarg1) {
100901     return (Dali::GestureDetector *)jarg1;
100902 }
100903
100904 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_TapGesture_SWIGUpcast(Dali::TapGesture *jarg1) {
100905     return (Dali::Gesture *)jarg1;
100906 }
100907
100908 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyFrames_SWIGUpcast(Dali::KeyFrames *jarg1) {
100909     return (Dali::BaseHandle *)jarg1;
100910 }
100911
100912 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Path_SWIGUpcast(Dali::Path *jarg1) {
100913     return (Dali::Handle *)jarg1;
100914 }
100915
100916 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_LinearConstrainer_SWIGUpcast(Dali::LinearConstrainer *jarg1) {
100917     return (Dali::Handle *)jarg1;
100918 }
100919
100920 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_PathConstrainer_SWIGUpcast(Dali::PathConstrainer *jarg1) {
100921     return (Dali::Handle *)jarg1;
100922 }
100923
100924 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_BufferImage_SWIGUpcast(Dali::BufferImage *jarg1) {
100925     return (Dali::Image *)jarg1;
100926 }
100927
100928 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_SWIGUpcast(Dali::EncodedBufferImage *jarg1) {
100929     return (Dali::Image *)jarg1;
100930 }
100931
100932 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_NativeImage_SWIGUpcast(Dali::NativeImage *jarg1) {
100933     return (Dali::Image *)jarg1;
100934 }
100935
100936 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_NativeImageInterface_SWIGUpcast(Dali::NativeImageInterface *jarg1) {
100937     return (Dali::RefObject *)jarg1;
100938 }
100939
100940 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_ResourceImage_SWIGUpcast(Dali::ResourceImage *jarg1) {
100941     return (Dali::Image *)jarg1;
100942 }
100943
100944 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_FrameBufferImage_SWIGUpcast(Dali::FrameBufferImage *jarg1) {
100945     return (Dali::Image *)jarg1;
100946 }
100947
100948 SWIGEXPORT Dali::ResourceImage * SWIGSTDCALL CSharp_Dali_NinePatchImage_SWIGUpcast(Dali::NinePatchImage *jarg1) {
100949     return (Dali::ResourceImage *)jarg1;
100950 }
100951
100952 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CameraActor_SWIGUpcast(Dali::CameraActor *jarg1) {
100953     return (Dali::Actor *)jarg1;
100954 }
100955
100956 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Timer_SWIGUpcast(Dali::Timer *jarg1) {
100957     return (Dali::BaseHandle *)jarg1;
100958 }
100959
100960 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_SWIGUpcast(Dali::DragAndDropDetector *jarg1) {
100961     return (Dali::BaseHandle *)jarg1;
100962 }
100963
100964
100965 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Builder_SWIGUpcast(Dali::Toolkit::Builder *jarg1) {
100966     return (Dali::BaseHandle *)jarg1;
100967 }
100968
100969 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TransitionData_SWIGUpcast(Dali::Toolkit::TransitionData *jarg1) {
100970     return (Dali::BaseHandle *)jarg1;
100971 }
100972
100973 SWIGEXPORT Dali::CustomActorImpl * SWIGSTDCALL CSharp_Dali_ViewImpl_SWIGUpcast(Dali::Toolkit::Internal::Control *jarg1) {
100974     return (Dali::CustomActorImpl *)jarg1;
100975 }
100976
100977 SWIGEXPORT Dali::CustomActor * SWIGSTDCALL CSharp_Dali_View_SWIGUpcast(Dali::Toolkit::Control *jarg1) {
100978     return (Dali::CustomActor *)jarg1;
100979 }
100980
100981 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SWIGUpcast(Dali::Toolkit::KeyInputFocusManager *jarg1) {
100982     return (Dali::BaseHandle *)jarg1;
100983 }
100984
100985 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Alignment_SWIGUpcast(Dali::Toolkit::Alignment *jarg1) {
100986     return (Dali::Toolkit::Control *)jarg1;
100987 }
100988
100989 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Button_SWIGUpcast(Dali::Toolkit::Button *jarg1) {
100990     return (Dali::Toolkit::Control *)jarg1;
100991 }
100992
100993 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_CheckBoxButton_SWIGUpcast(Dali::Toolkit::CheckBoxButton *jarg1) {
100994     return (Dali::Toolkit::Button *)jarg1;
100995 }
100996
100997 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_PushButton_SWIGUpcast(Dali::Toolkit::PushButton *jarg1) {
100998     return (Dali::Toolkit::Button *)jarg1;
100999 }
101000
101001 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_RadioButton_SWIGUpcast(Dali::Toolkit::RadioButton *jarg1) {
101002     return (Dali::Toolkit::Button *)jarg1;
101003 }
101004
101005 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_FlexContainer_SWIGUpcast(Dali::Toolkit::FlexContainer *jarg1) {
101006     return (Dali::Toolkit::Control *)jarg1;
101007 }
101008
101009 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ImageView_SWIGUpcast(Dali::Toolkit::ImageView *jarg1) {
101010     return (Dali::Toolkit::Control *)jarg1;
101011 }
101012
101013 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Model3dView_SWIGUpcast(Dali::Toolkit::Model3dView *jarg1) {
101014     return (Dali::Toolkit::Control *)jarg1;
101015 }
101016
101017 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ScrollBar_SWIGUpcast(Dali::Toolkit::ScrollBar *jarg1) {
101018     return (Dali::Toolkit::Control *)jarg1;
101019 }
101020
101021 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Scrollable_SWIGUpcast(Dali::Toolkit::Scrollable *jarg1) {
101022     return (Dali::Toolkit::Control *)jarg1;
101023 }
101024
101025 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_ItemLayout_SWIGUpcast(Dali::Toolkit::ItemLayout *jarg1) {
101026     return (Dali::RefObject *)jarg1;
101027 }
101028
101029 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ItemView_SWIGUpcast(Dali::Toolkit::ItemView *jarg1) {
101030     return (Dali::Toolkit::Scrollable *)jarg1;
101031 }
101032
101033 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ScrollViewEffect_SWIGUpcast(Dali::Toolkit::ScrollViewEffect *jarg1) {
101034     return (Dali::BaseHandle *)jarg1;
101035 }
101036
101037 SWIGEXPORT Dali::Toolkit::ScrollViewEffect * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_SWIGUpcast(Dali::Toolkit::ScrollViewPagePathEffect *jarg1) {
101038     return (Dali::Toolkit::ScrollViewEffect *)jarg1;
101039 }
101040
101041 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_Ruler_SWIGUpcast(Dali::Toolkit::Ruler *jarg1) {
101042     return (Dali::RefObject *)jarg1;
101043 }
101044
101045 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_DefaultRuler_SWIGUpcast(Dali::Toolkit::DefaultRuler *jarg1) {
101046     return (Dali::Toolkit::Ruler *)jarg1;
101047 }
101048
101049 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_FixedRuler_SWIGUpcast(Dali::Toolkit::FixedRuler *jarg1) {
101050     return (Dali::Toolkit::Ruler *)jarg1;
101051 }
101052
101053 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ScrollView_SWIGUpcast(Dali::Toolkit::ScrollView *jarg1) {
101054     return (Dali::Toolkit::Scrollable *)jarg1;
101055 }
101056
101057 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TableView_SWIGUpcast(Dali::Toolkit::TableView *jarg1) {
101058     return (Dali::Toolkit::Control *)jarg1;
101059 }
101060
101061
101062 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextLabel_SWIGUpcast(Dali::Toolkit::TextLabel *jarg1) {
101063     return (Dali::Toolkit::Control *)jarg1;
101064 }
101065
101066 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AccessibilityManager_SWIGUpcast(Dali::Toolkit::AccessibilityManager *jarg1) {
101067     return (Dali::BaseHandle *)jarg1;
101068 }
101069
101070 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_StyleManager_SWIGUpcast(Dali::Toolkit::StyleManager *jarg1) {
101071     return (Dali::BaseHandle *)jarg1;
101072 }
101073
101074 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Slider_SWIGUpcast(Dali::Toolkit::Slider *jarg1) {
101075     return (Dali::Toolkit::Control *)jarg1;
101076 }
101077
101078 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_VideoView_SWIGUpcast(Dali::Toolkit::VideoView *jarg1) {
101079     return (Dali::Toolkit::Control *)jarg1;
101080 }
101081
101082 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Popup_SWIGUpcast(Dali::Toolkit::Popup *jarg1) {
101083     return (Dali::Toolkit::Control *)jarg1;
101084 }
101085
101086 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ProgressBar_SWIGUpcast(Dali::Toolkit::ProgressBar *jarg1) {
101087     return (Dali::Toolkit::Control *)jarg1;
101088 }
101089
101090 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_GaussianBlurView_SWIGUpcast(Dali::Toolkit::GaussianBlurView *jarg1) {
101091     return (Dali::Toolkit::Control *)jarg1;
101092 }
101093
101094 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_PageTurnView_SWIGUpcast(Dali::Toolkit::PageTurnView *jarg1) {
101095     return (Dali::Toolkit::Control *)jarg1;
101096 }
101097
101098 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_SWIGUpcast(Dali::Toolkit::PageTurnLandscapeView *jarg1) {
101099     return (Dali::Toolkit::PageTurnView *)jarg1;
101100 }
101101
101102 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_SWIGUpcast(Dali::Toolkit::PageTurnPortraitView *jarg1) {
101103     return (Dali::Toolkit::PageTurnView *)jarg1;
101104 }
101105
101106 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_ToggleButton_SWIGUpcast(Dali::Toolkit::ToggleButton *jarg1) {
101107     return (Dali::Toolkit::Button *)jarg1;
101108 }
101109
101110 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualBase_SWIGUpcast(Dali::Toolkit::Visual::Base *jarg1) {
101111     return (Dali::BaseHandle *)jarg1;
101112 }
101113
101114 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualFactory_SWIGUpcast(Dali::Toolkit::VisualFactory *jarg1) {
101115     return (Dali::BaseHandle *)jarg1;
101116 }
101117
101118 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_SWIGUpcast(Dali::Toolkit::AsyncImageLoader *jarg1) {
101119     return (Dali::BaseHandle *)jarg1;
101120 }
101121
101122 /*
101123  * Widget binding
101124  */
101125 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Widget_SWIGUpcast(Dali::Widget *jarg1) {
101126     return (Dali::BaseHandle *)jarg1;
101127 }
101128
101129 SWIGEXPORT Dali::BaseObject * SWIGSTDCALL CSharp_Dali_WidgetImpl_SWIGUpcast(Dali::Internal::Adaptor::Widget *jarg1) {
101130     return (Dali::BaseObject *)jarg1;
101131 }
101132
101133 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_New__SWIG_0() {
101134   void * jresult ;
101135   Dali::Widget result;
101136
101137   {
101138     try {
101139       result = Dali::Widget::New();
101140     } catch (std::out_of_range& e) {
101141       {
101142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101143       };
101144     } catch (std::exception& e) {
101145       {
101146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101147       };
101148     } catch (...) {
101149       {
101150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101151       };
101152     }
101153   }
101154   jresult = new Dali::Widget((const Dali::Widget &)result);
101155   return jresult;
101156 }
101157
101158
101159 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_New__SWIG_1(void * jarg1) {
101160   void * jresult ;
101161   Dali::Internal::Adaptor::Widget *arg1 = 0 ;
101162   Dali::Widget result;
101163
101164   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101165
101166   if (!arg1) {
101167     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Internal::Adaptor::Widget & type is null", 0);
101168     return 0;
101169   }
101170   {
101171     try {
101172       jresult = new Dali::Widget(arg1);
101173     } catch (std::out_of_range& e) {
101174       {
101175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101176       };
101177     } catch (std::exception& e) {
101178       {
101179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101180       };
101181     } catch (...) {
101182       {
101183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101184       };
101185     }
101186   }
101187   return jresult;
101188 }
101189
101190
101191 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Widget() {
101192   void * jresult ;
101193   Dali::Widget *result = 0 ;
101194
101195   {
101196     try {
101197       result = (Dali::Widget *)new Dali::Widget();
101198     } catch (std::out_of_range& e) {
101199       {
101200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101201       };
101202     } catch (std::exception& e) {
101203       {
101204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101205       };
101206     } catch (...) {
101207       {
101208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101209       };
101210     }
101211   }
101212   jresult = (void *)result;
101213   return jresult;
101214 }
101215
101216
101217 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_Assign(void * jarg1, void * jarg2) {
101218   void * jresult ;
101219   Dali::Widget *arg1 = (Dali::Widget *) 0 ;
101220   Dali::Widget *arg2 = 0 ;
101221   Dali::Widget *result = 0 ;
101222
101223   arg1 = (Dali::Widget *)jarg1;
101224   arg2 = (Dali::Widget *)jarg2;
101225   if (!arg2) {
101226     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Widget const & type is null", 0);
101227     return 0;
101228   }
101229   {
101230     try {
101231       result = (Dali::Widget *) &(arg1)->operator =((Dali::Widget const &)*arg2);
101232     } catch (std::out_of_range& e) {
101233       {
101234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101235       };
101236     } catch (std::exception& e) {
101237       {
101238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101239       };
101240     } catch (...) {
101241       {
101242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101243       };
101244     }
101245   }
101246   jresult = (void *)result;
101247   return jresult;
101248 }
101249
101250
101251 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Widget(void * jarg1) {
101252   Dali::Widget *arg1 = (Dali::Widget *) 0 ;
101253
101254   arg1 = (Dali::Widget *)jarg1;
101255   {
101256     try {
101257       delete arg1;
101258     } catch (std::out_of_range& e) {
101259       {
101260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101261       };
101262     } catch (std::exception& e) {
101263       {
101264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101265       };
101266     } catch (...) {
101267       {
101268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101269       };
101270     }
101271   }
101272 }
101273
101274
101275 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetImpl_New() {
101276   void * jresult ;
101277   SwigDirector_WidgetImpl* result;
101278   {
101279     try {
101280       result = new SwigDirector_WidgetImpl();
101281     } catch (std::out_of_range& e) {
101282       {
101283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101284       };
101285     } catch (std::exception& e) {
101286       {
101287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101288       };
101289     } catch (...) {
101290       {
101291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101292       };
101293     }
101294   }
101295   jresult = result;
101296   return jresult;
101297 }
101298
101299
101300 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnCreate(void * jarg1, char * jarg2, void * jarg3) {
101301   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101302   std::string *arg2 = 0 ;
101303   Dali::Window arg3 ;
101304   Dali::Window *argp3 ;
101305
101306   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101307   if (!jarg2) {
101308     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101309     return ;
101310   }
101311   std::string arg2_str(jarg2);
101312   arg2 = &arg2_str;
101313   argp3 = (Dali::Window *)jarg3;
101314   if (!argp3) {
101315     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
101316     return ;
101317   }
101318   arg3 = *argp3;
101319   {
101320     try {
101321       (arg1)->OnCreate((std::string const &)*arg2,arg3);
101322     } catch (std::out_of_range& e) {
101323       {
101324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101325       };
101326     } catch (std::exception& e) {
101327       {
101328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101329       };
101330     } catch (...) {
101331       {
101332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101333       };
101334     }
101335   }
101336 }
101337
101338 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnCreateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, void * jarg3) {
101339   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101340   std::string *arg2 = 0 ;
101341   Dali::Window arg3 ;
101342   Dali::Window *argp3 ;
101343
101344   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101345   if (!jarg2) {
101346     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101347     return ;
101348   }
101349   std::string arg2_str(jarg2);
101350   arg2 = &arg2_str;
101351   argp3 = (Dali::Window *)jarg3;
101352   if (!argp3) {
101353     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
101354     return ;
101355   }
101356   arg3 = *argp3;
101357   {
101358     try {
101359       (arg1)->Dali::Internal::Adaptor::Widget::OnCreate((std::string const &)*arg2,arg3);
101360     } catch (std::out_of_range& e) {
101361       {
101362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101363       };
101364     } catch (std::exception& e) {
101365       {
101366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101367       };
101368     } catch (...) {
101369       {
101370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101371       };
101372     }
101373   }
101374 }
101375
101376
101377 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnTerminate(void * jarg1, char * jarg2, int jarg3) {
101378   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101379   std::string *arg2 = 0 ;
101380   Dali::Widget::Termination arg3 ;
101381
101382   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101383   if (!jarg2) {
101384     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101385     return ;
101386   }
101387   std::string arg2_str(jarg2);
101388   arg2 = &arg2_str;
101389   arg3 = (Dali::Widget::Termination)jarg3;
101390   {
101391     try {
101392       (arg1)->OnTerminate((std::string const &)*arg2,arg3);
101393     } catch (std::out_of_range& e) {
101394       {
101395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101396       };
101397     } catch (std::exception& e) {
101398       {
101399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101400       };
101401     } catch (...) {
101402       {
101403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101404       };
101405     }
101406   }
101407 }
101408
101409 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnTerminateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, int jarg3) {
101410   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101411   std::string *arg2 = 0 ;
101412   Dali::Widget::Termination arg3 ;
101413
101414   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101415   if (!jarg2) {
101416     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101417     return ;
101418   }
101419   std::string arg2_str(jarg2);
101420   arg2 = &arg2_str;
101421   arg3 = (Dali::Widget::Termination)jarg3;
101422   {
101423     try {
101424       (arg1)->Dali::Internal::Adaptor::Widget::OnTerminate((std::string const &)*arg2,arg3);
101425     } catch (std::out_of_range& e) {
101426       {
101427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101428       };
101429     } catch (std::exception& e) {
101430       {
101431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101432       };
101433     } catch (...) {
101434       {
101435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101436       };
101437     }
101438   }
101439 }
101440
101441
101442 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnPause(void * jarg1) {
101443   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101444
101445   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101446   {
101447     try {
101448       (arg1)->OnPause();
101449     } catch (std::out_of_range& e) {
101450       {
101451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101452       };
101453     } catch (std::exception& e) {
101454       {
101455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101456       };
101457     } catch (...) {
101458       {
101459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101460       };
101461     }
101462   }
101463 }
101464
101465 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnPauseSwigExplicitWidgetImpl(void * jarg1) {
101466   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101467
101468   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101469   {
101470     try {
101471       (arg1)->Dali::Internal::Adaptor::Widget::OnPause();
101472     } catch (std::out_of_range& e) {
101473       {
101474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101475       };
101476     } catch (std::exception& e) {
101477       {
101478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101479       };
101480     } catch (...) {
101481       {
101482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101483       };
101484     }
101485   }
101486 }
101487
101488
101489 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResume(void * jarg1) {
101490   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101491
101492   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101493   {
101494     try {
101495       (arg1)->OnResume();
101496     } catch (std::out_of_range& e) {
101497       {
101498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101499       };
101500     } catch (std::exception& e) {
101501       {
101502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101503       };
101504     } catch (...) {
101505       {
101506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101507       };
101508     }
101509   }
101510 }
101511
101512
101513 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResumeSwigExplicitWidgetImpl(void * jarg1) {
101514   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101515
101516   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101517   {
101518     try {
101519       (arg1)->Dali::Internal::Adaptor::Widget::OnResume();
101520     } catch (std::out_of_range& e) {
101521       {
101522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101523       };
101524     } catch (std::exception& e) {
101525       {
101526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101527       };
101528     } catch (...) {
101529       {
101530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101531       };
101532     }
101533   }
101534 }
101535
101536
101537 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResize(void * jarg1, void * jarg2) {
101538   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101539   Dali::Window arg2 ;
101540   Dali::Window *argp2 ;
101541
101542   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101543   argp2 = (Dali::Window *)jarg2;
101544   if (!argp2) {
101545     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
101546     return ;
101547   }
101548   arg2 = *argp2;
101549   {
101550     try {
101551       (arg1)->OnResize(arg2);
101552     } catch (std::out_of_range& e) {
101553       {
101554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101555       };
101556     } catch (std::exception& e) {
101557       {
101558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101559       };
101560     } catch (...) {
101561       {
101562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101563       };
101564     }
101565   }
101566 }
101567
101568 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResizeSwigExplicitWidgetImpl(void * jarg1, void * jarg2) {
101569   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101570   Dali::Window arg2 ;
101571   Dali::Window *argp2 ;
101572
101573   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101574   argp2 = (Dali::Window *)jarg2;
101575   if (!argp2) {
101576     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
101577     return ;
101578   }
101579   arg2 = *argp2;
101580   {
101581     try {
101582       (arg1)->Dali::Internal::Adaptor::Widget::OnResize(arg2);
101583     } catch (std::out_of_range& e) {
101584       {
101585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101586       };
101587     } catch (std::exception& e) {
101588       {
101589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101590       };
101591     } catch (...) {
101592       {
101593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101594       };
101595     }
101596   }
101597 }
101598
101599
101600 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnUpdate(void * jarg1, char * jarg2, int jarg3) {
101601   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101602   std::string *arg2 = 0 ;
101603   int arg3 ;
101604
101605   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101606   if (!jarg2) {
101607     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101608     return ;
101609   }
101610   std::string arg2_str(jarg2);
101611   arg2 = &arg2_str;
101612   arg3 = (int)jarg3;
101613   {
101614     try {
101615       (arg1)->OnUpdate((std::string const &)*arg2,arg3);
101616     } catch (std::out_of_range& e) {
101617       {
101618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101619       };
101620     } catch (std::exception& e) {
101621       {
101622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101623       };
101624     } catch (...) {
101625       {
101626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101627       };
101628     }
101629   }
101630 }
101631
101632 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnUpdateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, int jarg3) {
101633   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101634   std::string *arg2 = 0 ;
101635   int arg3 ;
101636
101637   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101638   if (!jarg2) {
101639     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101640     return ;
101641   }
101642   std::string arg2_str(jarg2);
101643   arg2 = &arg2_str;
101644   arg3 = (int)jarg3;
101645   {
101646     try {
101647       (arg1)->Dali::Internal::Adaptor::Widget::OnUpdate((std::string const &)*arg2,arg3);
101648     } catch (std::out_of_range& e) {
101649       {
101650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101651       };
101652     } catch (std::exception& e) {
101653       {
101654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101655       };
101656     } catch (...) {
101657       {
101658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101659       };
101660     }
101661   }
101662 }
101663
101664
101665 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
101666   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101667   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
101668   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
101669
101670   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101671   arg2 = (Dali::SlotObserver *)jarg2;
101672   arg3 = (Dali::CallbackBase *)jarg3;
101673   {
101674     try {
101675       (arg1)->SignalConnected(arg2,arg3);
101676     } catch (std::out_of_range& e) {
101677       {
101678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101679       };
101680     } catch (std::exception& e) {
101681       {
101682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101683       };
101684     } catch (...) {
101685       {
101686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101687       };
101688     }
101689   }
101690 }
101691
101692 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalConnectedSwigExplicitWidgetImpl(void * jarg1, void * jarg2, void * jarg3) {
101693   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101694   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
101695   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
101696
101697   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101698   arg2 = (Dali::SlotObserver *)jarg2;
101699   arg3 = (Dali::CallbackBase *)jarg3;
101700   {
101701     try {
101702       (arg1)->Dali::Internal::Adaptor::Widget::SignalConnected(arg2,arg3);
101703     } catch (std::out_of_range& e) {
101704       {
101705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101706       };
101707     } catch (std::exception& e) {
101708       {
101709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101710       };
101711     } catch (...) {
101712       {
101713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101714       };
101715     }
101716   }
101717 }
101718
101719
101720 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
101721   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101722   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
101723   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
101724
101725   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101726   arg2 = (Dali::SlotObserver *)jarg2;
101727   arg3 = (Dali::CallbackBase *)jarg3;
101728   {
101729     try {
101730       (arg1)->SignalDisconnected(arg2,arg3);
101731     } catch (std::out_of_range& e) {
101732       {
101733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101734       };
101735     } catch (std::exception& e) {
101736       {
101737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101738       };
101739     } catch (...) {
101740       {
101741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101742       };
101743     }
101744   }
101745 }
101746
101747 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalDisconnectedSwigExplicitWidgetImpl(void * jarg1, void * jarg2, void * jarg3) {
101748   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101749   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
101750   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
101751
101752   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101753   arg2 = (Dali::SlotObserver *)jarg2;
101754   arg3 = (Dali::CallbackBase *)jarg3;
101755   {
101756     try {
101757       (arg1)->Dali::Internal::Adaptor::Widget::SignalDisconnected(arg2,arg3);
101758     } catch (std::out_of_range& e) {
101759       {
101760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101761       };
101762     } catch (std::exception& e) {
101763       {
101764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101765       };
101766     } catch (...) {
101767       {
101768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101769       };
101770     }
101771   }
101772 }
101773
101774 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SetContentInfo(void * jarg1, char * jarg2) {
101775   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101776   std::string *arg2 = 0 ;
101777
101778   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101779   if (!jarg2) {
101780     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101781     return ;
101782   }
101783   std::string arg2_str(jarg2);
101784   arg2 = &arg2_str;
101785   {
101786     try {
101787       (arg1)->SetContentInfo((std::string const &)*arg2);
101788     } catch (std::out_of_range& e) {
101789       {
101790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101791       };
101792     } catch (std::exception& e) {
101793       {
101794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101795       };
101796     } catch (...) {
101797       {
101798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101799       };
101800     }
101801   }
101802 }
101803
101804
101805 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SetImpl(void * jarg1, void * jarg2) {
101806   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101807   Dali::Internal::Adaptor::Widget::Impl *arg2 = (Dali::Internal::Adaptor::Widget::Impl *) 0 ;
101808
101809   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101810   arg2 = (Dali::Internal::Adaptor::Widget::Impl *)jarg2;
101811   {
101812     try {
101813       (arg1)->SetImpl(arg2);
101814     } catch (std::out_of_range& e) {
101815       {
101816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101817       };
101818     } catch (std::exception& e) {
101819       {
101820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101821       };
101822     } catch (...) {
101823       {
101824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101825       };
101826     }
101827   }
101828 }
101829
101830 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) {
101831
101832   SwigDirector_WidgetImpl *director = static_cast<SwigDirector_WidgetImpl *>(objarg);
101833   if (director) {
101834     director->swig_connect_director(callback0, callback1, callback2, callback3, callback4, callback5, callback6, callback7);
101835   }
101836 }
101837
101838 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_GetImplementation__SWIG_0(void * jarg1) {
101839   void * jresult ;
101840   Dali::Widget *arg1 = 0 ;
101841   SwigDirector_WidgetImpl *result = 0 ;
101842
101843   arg1 = (Dali::Widget *)jarg1;
101844   if (!arg1) {
101845     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Widget & type is null", 0);
101846     return 0;
101847   }
101848   {
101849     try {
101850       result = (SwigDirector_WidgetImpl *) &Dali::Internal::Adaptor::GetImplementation(*arg1);
101851     } catch (std::out_of_range& e) {
101852       {
101853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101854       };
101855     } catch (std::exception& e) {
101856       {
101857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101858       };
101859     } catch (...) {
101860       {
101861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101862       };
101863     }
101864   }
101865
101866   jresult = (void *)result;
101867   return jresult;
101868 }
101869
101870
101871 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetApplication_New(int jarg1, char * jarg2, char * jarg3) {
101872   void * jresult ;
101873   int *arg1 = (int *) 0 ;
101874   char ***arg2 ;
101875   std::string *arg3 = 0 ;
101876   Dali::WidgetApplication result;
101877   {
101878     int index = 0;
101879     int length = 0;
101880     char *retPtr;
101881     char *nextPtr;
101882     argWidgetC = jarg1;
101883     argWidgetV = new char*[jarg1 + 1];
101884
101885     retPtr = strtok_r( jarg2, " ", &nextPtr);
101886     if( retPtr )
101887     {
101888       length = strlen(retPtr);
101889     }
101890     argWidgetV[index] = new char[length + 1];
101891     if( retPtr )
101892     {
101893       strncpy(argWidgetV[index], retPtr, length);
101894     }
101895     argWidgetV[index][length] = '\0';
101896     index++;
101897
101898     while (index < jarg1)
101899     {
101900       length = 0;
101901       retPtr = strtok_r(NULL, " ", &nextPtr);
101902       if( retPtr )
101903       {
101904         length = strlen(retPtr);
101905       }
101906       argWidgetV[index] = new char[length + 1];
101907       if( retPtr )
101908       {
101909         strncpy(argWidgetV[index], retPtr, length);
101910       }
101911       argWidgetV[index][length] = '\0';
101912       index++;
101913     }
101914
101915     argWidgetV[jarg1] = NULL;
101916     argWidgetC = jarg1;
101917
101918     arg1 = &argWidgetC;
101919     arg2 = &argWidgetV;
101920   }
101921
101922   if (!jarg3) {
101923     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101924     return 0;
101925   }
101926   std::string arg3_str(jarg3);
101927   arg3 = &arg3_str;
101928   {
101929     try {
101930       result = Dali::WidgetApplication::New(arg1,arg2,(std::string const &)*arg3);
101931     } catch (std::out_of_range& e) {
101932       {
101933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101934       };
101935     } catch (std::exception& e) {
101936       {
101937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101938       };
101939     } catch (...) {
101940       {
101941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101942       };
101943     }
101944   }
101945   jresult = new Dali::WidgetApplication((const Dali::WidgetApplication &)result);
101946
101947   return jresult;
101948 }
101949
101950
101951 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WidgetApplication__SWIG_0() {
101952   void * jresult ;
101953   Dali::WidgetApplication *result = 0 ;
101954
101955   {
101956     try {
101957       result = (Dali::WidgetApplication *)new Dali::WidgetApplication();
101958     } catch (std::out_of_range& e) {
101959       {
101960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101961       };
101962     } catch (std::exception& e) {
101963       {
101964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101965       };
101966     } catch (...) {
101967       {
101968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101969       };
101970     }
101971   }
101972   jresult = (void *)result;
101973   return jresult;
101974 }
101975
101976
101977 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WidgetApplication__SWIG_1(void * jarg1) {
101978   void * jresult ;
101979   Dali::WidgetApplication *arg1 = 0 ;
101980   Dali::WidgetApplication *result = 0 ;
101981
101982   arg1 = (Dali::WidgetApplication *)jarg1;
101983   if (!arg1) {
101984     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WidgetApplication const & type is null", 0);
101985     return 0;
101986   }
101987   {
101988     try {
101989       result = (Dali::WidgetApplication *)new Dali::WidgetApplication((Dali::WidgetApplication const &)*arg1);
101990     } catch (std::out_of_range& e) {
101991       {
101992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101993       };
101994     } catch (std::exception& e) {
101995       {
101996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101997       };
101998     } catch (...) {
101999       {
102000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102001       };
102002     }
102003   }
102004   jresult = (void *)result;
102005   return jresult;
102006 }
102007
102008
102009 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetApplication_Assign(void * jarg1, void * jarg2) {
102010   void * jresult ;
102011   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
102012   Dali::WidgetApplication *arg2 = 0 ;
102013   Dali::WidgetApplication *result = 0 ;
102014
102015   arg1 = (Dali::WidgetApplication *)jarg1;
102016   arg2 = (Dali::WidgetApplication *)jarg2;
102017   if (!arg2) {
102018     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WidgetApplication const & type is null", 0);
102019     return 0;
102020   }
102021   {
102022     try {
102023       result = (Dali::WidgetApplication *) &(arg1)->operator =((Dali::WidgetApplication const &)*arg2);
102024     } catch (std::out_of_range& e) {
102025       {
102026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102027       };
102028     } catch (std::exception& e) {
102029       {
102030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102031       };
102032     } catch (...) {
102033       {
102034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102035       };
102036     }
102037   }
102038   jresult = (void *)result;
102039   return jresult;
102040 }
102041
102042
102043 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WidgetApplication(void * jarg1) {
102044   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
102045
102046   arg1 = (Dali::WidgetApplication *)jarg1;
102047   {
102048     try {
102049       delete arg1;
102050       if( argWidgetV )
102051       {
102052         // free string data
102053         for( int i=0; i < argWidgetC+1; i++)
102054         {
102055           delete [] argWidgetV[i];
102056         }
102057         delete [] argWidgetV;
102058       }
102059     } catch (std::out_of_range& e) {
102060       {
102061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102062       };
102063     } catch (std::exception& e) {
102064       {
102065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102066       };
102067     } catch (...) {
102068       {
102069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102070       };
102071     }
102072   }
102073 }
102074
102075
102076 typedef Dali::Widget*(SWIGSTDCALL *CSharpCreateWidgetFunction)(const std::string&);
102077 CSharpCreateWidgetFunction _CSharpCreateWidgetFunction = NULL;
102078
102079 static Dali::Widget SWIGSTDCALL WidgetFactoryFunction( const std::string& widgetName )
102080 {
102081   Widget* widget = _CSharpCreateWidgetFunction( widgetName.c_str() );
102082   return *widget;
102083 }
102084
102085 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetApplication_RegisterWidgetCreatingFunction(void * jarg1, char** jarg2, void * jarg3) {
102086   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
102087   std::string *arg2 = 0 ;
102088
102089   arg1 = (Dali::WidgetApplication *)jarg1;
102090   if (!jarg2) {
102091     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102092     return ;
102093   }
102094   std::string arg2_str(*jarg2);
102095   arg2 = &arg2_str;
102096
102097   if(!_CSharpCreateWidgetFunction)
102098   {
102099     _CSharpCreateWidgetFunction = (Dali::Widget*(*)(const std::string&))jarg3;
102100   }
102101
102102   {
102103     try {
102104       (arg1)->RegisterWidgetCreatingFunction((std::string const &)*arg2, WidgetFactoryFunction);
102105     } catch (std::out_of_range& e) {
102106       {
102107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102108       };
102109     } catch (std::exception& e) {
102110       {
102111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102112       };
102113     } catch (...) {
102114       {
102115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102116       };
102117     }
102118   }
102119
102120   //Typemap argout in c++ file.
102121   //This will convert c++ string to c# string
102122   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
102123 }
102124
102125
102126 //for PixelBuffer and ImageLoading
102127
102128 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelBuffer_SWIGUpcast(Dali::Devel::PixelBuffer *jarg1) {
102129     return (Dali::BaseHandle *)jarg1;
102130 }
102131
102132 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_New(unsigned int jarg1, unsigned int jarg2, int jarg3) {
102133   void * jresult ;
102134   unsigned int arg1 ;
102135   unsigned int arg2 ;
102136   Dali::Pixel::Format arg3 ;
102137   Dali::Devel::PixelBuffer result;
102138
102139   arg1 = (unsigned int)jarg1;
102140   arg2 = (unsigned int)jarg2;
102141   arg3 = (Dali::Pixel::Format)jarg3;
102142   {
102143     try {
102144       result = Dali::Devel::PixelBuffer::New(arg1,arg2,arg3);
102145     } catch (std::out_of_range& e) {
102146       {
102147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102148       };
102149     } catch (std::exception& e) {
102150       {
102151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102152       };
102153     } catch (...) {
102154       {
102155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102156       };
102157     }
102158   }
102159   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
102160   return jresult;
102161 }
102162
102163
102164 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelBuffer__SWIG_0() {
102165   void * jresult ;
102166   Dali::Devel::PixelBuffer *result = 0 ;
102167
102168   {
102169     try {
102170       result = (Dali::Devel::PixelBuffer *)new Dali::Devel::PixelBuffer();
102171     } catch (std::out_of_range& e) {
102172       {
102173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102174       };
102175     } catch (std::exception& e) {
102176       {
102177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102178       };
102179     } catch (...) {
102180       {
102181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102182       };
102183     }
102184   }
102185   jresult = (void *)result;
102186   return jresult;
102187 }
102188
102189
102190 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelBuffer(void * jarg1) {
102191   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102192
102193   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102194   {
102195     try {
102196       delete arg1;
102197     } catch (std::out_of_range& e) {
102198       {
102199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102200       };
102201     } catch (std::exception& e) {
102202       {
102203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102204       };
102205     } catch (...) {
102206       {
102207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102208       };
102209     }
102210   }
102211 }
102212
102213
102214 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelBuffer__SWIG_1(void * jarg1) {
102215   void * jresult ;
102216   Dali::Devel::PixelBuffer *arg1 = 0 ;
102217   Dali::Devel::PixelBuffer *result = 0 ;
102218
102219   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102220   if (!arg1) {
102221     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer const & type is null", 0);
102222     return 0;
102223   }
102224   {
102225     try {
102226       result = (Dali::Devel::PixelBuffer *)new Dali::Devel::PixelBuffer((Dali::Devel::PixelBuffer const &)*arg1);
102227     } catch (std::out_of_range& e) {
102228       {
102229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102230       };
102231     } catch (std::exception& e) {
102232       {
102233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102234       };
102235     } catch (...) {
102236       {
102237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102238       };
102239     }
102240   }
102241   jresult = (void *)result;
102242   return jresult;
102243 }
102244
102245
102246 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_Assign(void * jarg1, void * jarg2) {
102247   void * jresult ;
102248   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102249   Dali::Devel::PixelBuffer *arg2 = 0 ;
102250   Dali::Devel::PixelBuffer *result = 0 ;
102251
102252   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102253   arg2 = (Dali::Devel::PixelBuffer *)jarg2;
102254   if (!arg2) {
102255     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer const & type is null", 0);
102256     return 0;
102257   }
102258   {
102259     try {
102260       result = (Dali::Devel::PixelBuffer *) &(arg1)->operator =((Dali::Devel::PixelBuffer const &)*arg2);
102261     } catch (std::out_of_range& e) {
102262       {
102263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102264       };
102265     } catch (std::exception& e) {
102266       {
102267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102268       };
102269     } catch (...) {
102270       {
102271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102272       };
102273     }
102274   }
102275   jresult = (void *)result;
102276   return jresult;
102277 }
102278
102279
102280 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_Convert(void * jarg1) {
102281   void * jresult ;
102282   Dali::Devel::PixelBuffer *arg1 = 0 ;
102283   Dali::PixelData result;
102284
102285   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102286   if (!arg1) {
102287     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer & type is null", 0);
102288     return 0;
102289   }
102290   {
102291     try {
102292       result = Dali::Devel::PixelBuffer::Convert(*arg1);
102293     } catch (std::out_of_range& e) {
102294       {
102295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102296       };
102297     } catch (std::exception& e) {
102298       {
102299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102300       };
102301     } catch (...) {
102302       {
102303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102304       };
102305     }
102306   }
102307   jresult = new Dali::PixelData((const Dali::PixelData &)result);
102308   return jresult;
102309 }
102310
102311
102312 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_CreatePixelData(void * jarg1) {
102313   void * jresult ;
102314   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102315   Dali::PixelData result;
102316
102317   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102318   {
102319     try {
102320       result = ((Dali::Devel::PixelBuffer const *)arg1)->CreatePixelData();
102321     } catch (std::out_of_range& e) {
102322       {
102323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102324       };
102325     } catch (std::exception& e) {
102326       {
102327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102328       };
102329     } catch (...) {
102330       {
102331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102332       };
102333     }
102334   }
102335   jresult = new Dali::PixelData((const Dali::PixelData &)result);
102336   return jresult;
102337 }
102338
102339
102340 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_GetBuffer(void * jarg1) {
102341   void * jresult ;
102342   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102343   unsigned char *result = 0 ;
102344
102345   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102346   {
102347     try {
102348       result = (unsigned char *)(arg1)->GetBuffer();
102349     } catch (std::out_of_range& e) {
102350       {
102351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102352       };
102353     } catch (std::exception& e) {
102354       {
102355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102356       };
102357     } catch (...) {
102358       {
102359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102360       };
102361     }
102362   }
102363   jresult = (void *)result;
102364   return jresult;
102365 }
102366
102367
102368 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetWidth(void * jarg1) {
102369   unsigned int jresult ;
102370   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102371   unsigned int result;
102372
102373   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102374   {
102375     try {
102376       result = (unsigned int)((Dali::Devel::PixelBuffer const *)arg1)->GetWidth();
102377     } catch (std::out_of_range& e) {
102378       {
102379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102380       };
102381     } catch (std::exception& e) {
102382       {
102383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102384       };
102385     } catch (...) {
102386       {
102387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102388       };
102389     }
102390   }
102391   jresult = result;
102392   return jresult;
102393 }
102394
102395
102396 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetHeight(void * jarg1) {
102397   unsigned int jresult ;
102398   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102399   unsigned int result;
102400
102401   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102402   {
102403     try {
102404       result = (unsigned int)((Dali::Devel::PixelBuffer const *)arg1)->GetHeight();
102405     } catch (std::out_of_range& e) {
102406       {
102407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102408       };
102409     } catch (std::exception& e) {
102410       {
102411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102412       };
102413     } catch (...) {
102414       {
102415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102416       };
102417     }
102418   }
102419   jresult = result;
102420   return jresult;
102421 }
102422
102423
102424 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetPixelFormat(void * jarg1) {
102425   int jresult ;
102426   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102427   Dali::Pixel::Format result;
102428
102429   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102430   {
102431     try {
102432       result = (Dali::Pixel::Format)((Dali::Devel::PixelBuffer const *)arg1)->GetPixelFormat();
102433     } catch (std::out_of_range& e) {
102434       {
102435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102436       };
102437     } catch (std::exception& e) {
102438       {
102439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102440       };
102441     } catch (...) {
102442       {
102443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102444       };
102445     }
102446   }
102447   jresult = (int)result;
102448   return jresult;
102449 }
102450
102451
102452 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_0(void * jarg1, void * jarg2, float jarg3, unsigned int jarg4) {
102453   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102454   Dali::Devel::PixelBuffer arg2 ;
102455   float arg3 ;
102456   bool arg4 ;
102457   Dali::Devel::PixelBuffer *argp2 ;
102458
102459   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102460   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
102461   if (!argp2) {
102462     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
102463     return ;
102464   }
102465   arg2 = *argp2;
102466   arg3 = (float)jarg3;
102467   arg4 = jarg4 ? true : false;
102468   {
102469     try {
102470       (arg1)->ApplyMask(arg2,arg3,arg4);
102471     } catch (std::out_of_range& e) {
102472       {
102473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102474       };
102475     } catch (std::exception& e) {
102476       {
102477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102478       };
102479     } catch (...) {
102480       {
102481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102482       };
102483     }
102484   }
102485 }
102486
102487
102488 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
102489   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102490   Dali::Devel::PixelBuffer arg2 ;
102491   float arg3 ;
102492   Dali::Devel::PixelBuffer *argp2 ;
102493
102494   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102495   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
102496   if (!argp2) {
102497     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
102498     return ;
102499   }
102500   arg2 = *argp2;
102501   arg3 = (float)jarg3;
102502   {
102503     try {
102504       (arg1)->ApplyMask(arg2,arg3);
102505     } catch (std::out_of_range& e) {
102506       {
102507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102508       };
102509     } catch (std::exception& e) {
102510       {
102511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102512       };
102513     } catch (...) {
102514       {
102515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102516       };
102517     }
102518   }
102519 }
102520
102521
102522 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_2(void * jarg1, void * jarg2) {
102523   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102524   Dali::Devel::PixelBuffer arg2 ;
102525   Dali::Devel::PixelBuffer *argp2 ;
102526
102527   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102528   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
102529   if (!argp2) {
102530     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
102531     return ;
102532   }
102533   arg2 = *argp2;
102534   {
102535     try {
102536       (arg1)->ApplyMask(arg2);
102537     } catch (std::out_of_range& e) {
102538       {
102539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102540       };
102541     } catch (std::exception& e) {
102542       {
102543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102544       };
102545     } catch (...) {
102546       {
102547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102548       };
102549     }
102550   }
102551 }
102552
102553
102554 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyGaussianBlur(void * jarg1, float jarg2) {
102555   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102556   float arg2 ;
102557
102558   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102559   arg2 = (float)jarg2;
102560   {
102561     try {
102562       (arg1)->ApplyGaussianBlur(arg2);
102563     } catch (std::out_of_range& e) {
102564       {
102565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102566       };
102567     } catch (std::exception& e) {
102568       {
102569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102570       };
102571     } catch (...) {
102572       {
102573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102574       };
102575     }
102576   }
102577 }
102578
102579
102580 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_Crop(void * jarg1, unsigned short jarg2, unsigned short jarg3, unsigned short jarg4, unsigned short jarg5) {
102581   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102582   uint16_t arg2 ;
102583   uint16_t arg3 ;
102584   uint16_t arg4 ;
102585   uint16_t arg5 ;
102586
102587   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102588   arg2 = (uint16_t)jarg2;
102589   arg3 = (uint16_t)jarg3;
102590   arg4 = (uint16_t)jarg4;
102591   arg5 = (uint16_t)jarg5;
102592   {
102593     try {
102594       (arg1)->Crop(arg2,arg3,arg4,arg5);
102595     } catch (std::out_of_range& e) {
102596       {
102597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102598       };
102599     } catch (std::exception& e) {
102600       {
102601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102602       };
102603     } catch (...) {
102604       {
102605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102606       };
102607     }
102608   }
102609 }
102610
102611
102612 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_Resize(void * jarg1, unsigned short jarg2, unsigned short jarg3) {
102613   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102614   uint16_t arg2 ;
102615   uint16_t arg3 ;
102616
102617   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102618   arg2 = (uint16_t)jarg2;
102619   arg3 = (uint16_t)jarg3;
102620   {
102621     try {
102622       (arg1)->Resize(arg2,arg3);
102623     } catch (std::out_of_range& e) {
102624       {
102625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102626       };
102627     } catch (std::exception& e) {
102628       {
102629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102630       };
102631     } catch (...) {
102632       {
102633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102634       };
102635     }
102636   }
102637 }
102638
102639
102640 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
102641   void * jresult ;
102642   std::string *arg1 = 0 ;
102643   Dali::ImageDimensions arg2 ;
102644   Dali::FittingMode::Type arg3 ;
102645   Dali::SamplingMode::Type arg4 ;
102646   bool arg5 ;
102647   Dali::ImageDimensions *argp2 ;
102648   Dali::Devel::PixelBuffer result;
102649
102650   if (!jarg1) {
102651     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102652     return 0;
102653   }
102654   std::string arg1_str(jarg1);
102655   arg1 = &arg1_str;
102656   argp2 = (Dali::ImageDimensions *)jarg2;
102657   if (!argp2) {
102658     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
102659     return 0;
102660   }
102661   arg2 = *argp2;
102662   arg3 = (Dali::FittingMode::Type)jarg3;
102663   arg4 = (Dali::SamplingMode::Type)jarg4;
102664   arg5 = jarg5 ? true : false;
102665   {
102666     try {
102667       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3,arg4,arg5);
102668     } catch (std::out_of_range& e) {
102669       {
102670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102671       };
102672     } catch (std::exception& e) {
102673       {
102674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102675       };
102676     } catch (...) {
102677       {
102678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102679       };
102680     }
102681   }
102682   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
102683
102684   return jresult;
102685 }
102686
102687
102688 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
102689   void * jresult ;
102690   std::string *arg1 = 0 ;
102691   Dali::ImageDimensions arg2 ;
102692   Dali::FittingMode::Type arg3 ;
102693   Dali::SamplingMode::Type arg4 ;
102694   Dali::ImageDimensions *argp2 ;
102695   Dali::Devel::PixelBuffer result;
102696
102697   if (!jarg1) {
102698     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102699     return 0;
102700   }
102701   std::string arg1_str(jarg1);
102702   arg1 = &arg1_str;
102703   argp2 = (Dali::ImageDimensions *)jarg2;
102704   if (!argp2) {
102705     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
102706     return 0;
102707   }
102708   arg2 = *argp2;
102709   arg3 = (Dali::FittingMode::Type)jarg3;
102710   arg4 = (Dali::SamplingMode::Type)jarg4;
102711   {
102712     try {
102713       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3,arg4);
102714     } catch (std::out_of_range& e) {
102715       {
102716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102717       };
102718     } catch (std::exception& e) {
102719       {
102720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102721       };
102722     } catch (...) {
102723       {
102724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102725       };
102726     }
102727   }
102728   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
102729
102730   return jresult;
102731 }
102732
102733
102734 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
102735   void * jresult ;
102736   std::string *arg1 = 0 ;
102737   Dali::ImageDimensions arg2 ;
102738   Dali::FittingMode::Type arg3 ;
102739   Dali::ImageDimensions *argp2 ;
102740   Dali::Devel::PixelBuffer result;
102741
102742   if (!jarg1) {
102743     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102744     return 0;
102745   }
102746   std::string arg1_str(jarg1);
102747   arg1 = &arg1_str;
102748   argp2 = (Dali::ImageDimensions *)jarg2;
102749   if (!argp2) {
102750     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
102751     return 0;
102752   }
102753   arg2 = *argp2;
102754   arg3 = (Dali::FittingMode::Type)jarg3;
102755   {
102756     try {
102757       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3);
102758     } catch (std::out_of_range& e) {
102759       {
102760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102761       };
102762     } catch (std::exception& e) {
102763       {
102764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102765       };
102766     } catch (...) {
102767       {
102768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102769       };
102770     }
102771   }
102772   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
102773
102774   return jresult;
102775 }
102776
102777
102778 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_3(char * jarg1, void * jarg2) {
102779   void * jresult ;
102780   std::string *arg1 = 0 ;
102781   Dali::ImageDimensions arg2 ;
102782   Dali::ImageDimensions *argp2 ;
102783   Dali::Devel::PixelBuffer result;
102784
102785   if (!jarg1) {
102786     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102787     return 0;
102788   }
102789   std::string arg1_str(jarg1);
102790   arg1 = &arg1_str;
102791   argp2 = (Dali::ImageDimensions *)jarg2;
102792   if (!argp2) {
102793     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
102794     return 0;
102795   }
102796   arg2 = *argp2;
102797   {
102798     try {
102799       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2);
102800     } catch (std::out_of_range& e) {
102801       {
102802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102803       };
102804     } catch (std::exception& e) {
102805       {
102806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102807       };
102808     } catch (...) {
102809       {
102810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102811       };
102812     }
102813   }
102814   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
102815
102816   return jresult;
102817 }
102818
102819
102820 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_4(char * jarg1) {
102821   void * jresult ;
102822   std::string *arg1 = 0 ;
102823   Dali::Devel::PixelBuffer result;
102824
102825   if (!jarg1) {
102826     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102827     return 0;
102828   }
102829   std::string arg1_str(jarg1);
102830   arg1 = &arg1_str;
102831   {
102832     try {
102833       result = Dali::LoadImageFromFile((std::string const &)*arg1);
102834     } catch (std::out_of_range& e) {
102835       {
102836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102837       };
102838     } catch (std::exception& e) {
102839       {
102840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102841       };
102842     } catch (...) {
102843       {
102844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102845       };
102846     }
102847   }
102848   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
102849
102850   return jresult;
102851 }
102852
102853
102854 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
102855   void * jresult ;
102856   std::string *arg1 = 0 ;
102857   Dali::ImageDimensions arg2 ;
102858   Dali::FittingMode::Type arg3 ;
102859   Dali::SamplingMode::Type arg4 ;
102860   bool arg5 ;
102861   Dali::ImageDimensions *argp2 ;
102862   Dali::ImageDimensions result;
102863
102864   if (!jarg1) {
102865     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102866     return 0;
102867   }
102868   std::string arg1_str(jarg1);
102869   arg1 = &arg1_str;
102870   argp2 = (Dali::ImageDimensions *)jarg2;
102871   if (!argp2) {
102872     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
102873     return 0;
102874   }
102875   arg2 = *argp2;
102876   arg3 = (Dali::FittingMode::Type)jarg3;
102877   arg4 = (Dali::SamplingMode::Type)jarg4;
102878   arg5 = jarg5 ? true : false;
102879   {
102880     try {
102881       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3,arg4,arg5);
102882     } catch (std::out_of_range& e) {
102883       {
102884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102885       };
102886     } catch (std::exception& e) {
102887       {
102888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102889       };
102890     } catch (...) {
102891       {
102892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102893       };
102894     }
102895   }
102896   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
102897
102898   return jresult;
102899 }
102900
102901
102902 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
102903   void * jresult ;
102904   std::string *arg1 = 0 ;
102905   Dali::ImageDimensions arg2 ;
102906   Dali::FittingMode::Type arg3 ;
102907   Dali::SamplingMode::Type arg4 ;
102908   Dali::ImageDimensions *argp2 ;
102909   Dali::ImageDimensions result;
102910
102911   if (!jarg1) {
102912     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102913     return 0;
102914   }
102915   std::string arg1_str(jarg1);
102916   arg1 = &arg1_str;
102917   argp2 = (Dali::ImageDimensions *)jarg2;
102918   if (!argp2) {
102919     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
102920     return 0;
102921   }
102922   arg2 = *argp2;
102923   arg3 = (Dali::FittingMode::Type)jarg3;
102924   arg4 = (Dali::SamplingMode::Type)jarg4;
102925   {
102926     try {
102927       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3,arg4);
102928     } catch (std::out_of_range& e) {
102929       {
102930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102931       };
102932     } catch (std::exception& e) {
102933       {
102934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102935       };
102936     } catch (...) {
102937       {
102938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102939       };
102940     }
102941   }
102942   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
102943
102944   return jresult;
102945 }
102946
102947
102948 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
102949   void * jresult ;
102950   std::string *arg1 = 0 ;
102951   Dali::ImageDimensions arg2 ;
102952   Dali::FittingMode::Type arg3 ;
102953   Dali::ImageDimensions *argp2 ;
102954   Dali::ImageDimensions result;
102955
102956   if (!jarg1) {
102957     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102958     return 0;
102959   }
102960   std::string arg1_str(jarg1);
102961   arg1 = &arg1_str;
102962   argp2 = (Dali::ImageDimensions *)jarg2;
102963   if (!argp2) {
102964     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
102965     return 0;
102966   }
102967   arg2 = *argp2;
102968   arg3 = (Dali::FittingMode::Type)jarg3;
102969   {
102970     try {
102971       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3);
102972     } catch (std::out_of_range& e) {
102973       {
102974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102975       };
102976     } catch (std::exception& e) {
102977       {
102978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102979       };
102980     } catch (...) {
102981       {
102982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102983       };
102984     }
102985   }
102986   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
102987
102988   return jresult;
102989 }
102990
102991
102992 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_3(char * jarg1, void * jarg2) {
102993   void * jresult ;
102994   std::string *arg1 = 0 ;
102995   Dali::ImageDimensions arg2 ;
102996   Dali::ImageDimensions *argp2 ;
102997   Dali::ImageDimensions result;
102998
102999   if (!jarg1) {
103000     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103001     return 0;
103002   }
103003   std::string arg1_str(jarg1);
103004   arg1 = &arg1_str;
103005   argp2 = (Dali::ImageDimensions *)jarg2;
103006   if (!argp2) {
103007     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103008     return 0;
103009   }
103010   arg2 = *argp2;
103011   {
103012     try {
103013       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2);
103014     } catch (std::out_of_range& e) {
103015       {
103016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103017       };
103018     } catch (std::exception& e) {
103019       {
103020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103021       };
103022     } catch (...) {
103023       {
103024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103025       };
103026     }
103027   }
103028   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
103029
103030   return jresult;
103031 }
103032
103033
103034 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_4(char * jarg1) {
103035   void * jresult ;
103036   std::string *arg1 = 0 ;
103037   Dali::ImageDimensions result;
103038
103039   if (!jarg1) {
103040     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103041     return 0;
103042   }
103043   std::string arg1_str(jarg1);
103044   arg1 = &arg1_str;
103045   {
103046     try {
103047       result = Dali::GetClosestImageSize((std::string const &)*arg1);
103048     } catch (std::out_of_range& e) {
103049       {
103050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103051       };
103052     } catch (std::exception& e) {
103053       {
103054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103055       };
103056     } catch (...) {
103057       {
103058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103059       };
103060     }
103061   }
103062   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
103063
103064   return jresult;
103065 }
103066
103067 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetOriginalImageSize(char * jarg1) {
103068   void * jresult ;
103069   std::string *arg1 = 0 ;
103070   Dali::ImageDimensions result;
103071
103072   if (!jarg1) {
103073     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103074     return 0;
103075   }
103076   std::string arg1_str(jarg1);
103077   arg1 = &arg1_str;
103078   {
103079     try {
103080       result = Dali::GetOriginalImageSize((std::string const &)*arg1);
103081     } catch (std::out_of_range& e) {
103082       {
103083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103084       };
103085     } catch (std::exception& e) {
103086       {
103087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103088       };
103089     } catch (...) {
103090       {
103091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103092       };
103093     }
103094   }
103095   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
103096
103097   return jresult;
103098 }
103099
103100 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
103101   void * jresult ;
103102   std::string *arg1 = 0 ;
103103   Dali::ImageDimensions arg2 ;
103104   Dali::FittingMode::Type arg3 ;
103105   Dali::SamplingMode::Type arg4 ;
103106   bool arg5 ;
103107   Dali::ImageDimensions *argp2 ;
103108   Dali::Devel::PixelBuffer result;
103109
103110   if (!jarg1) {
103111     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103112     return 0;
103113   }
103114   std::string arg1_str(jarg1);
103115   arg1 = &arg1_str;
103116   argp2 = (Dali::ImageDimensions *)jarg2;
103117   if (!argp2) {
103118     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103119     return 0;
103120   }
103121   arg2 = *argp2;
103122   arg3 = (Dali::FittingMode::Type)jarg3;
103123   arg4 = (Dali::SamplingMode::Type)jarg4;
103124   arg5 = jarg5 ? true : false;
103125   {
103126     try {
103127       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3,arg4,arg5);
103128     } catch (std::out_of_range& e) {
103129       {
103130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103131       };
103132     } catch (std::exception& e) {
103133       {
103134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103135       };
103136     } catch (...) {
103137       {
103138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103139       };
103140     }
103141   }
103142   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
103143
103144   return jresult;
103145 }
103146
103147
103148 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
103149   void * jresult ;
103150   std::string *arg1 = 0 ;
103151   Dali::ImageDimensions arg2 ;
103152   Dali::FittingMode::Type arg3 ;
103153   Dali::SamplingMode::Type arg4 ;
103154   Dali::ImageDimensions *argp2 ;
103155   Dali::Devel::PixelBuffer result;
103156
103157   if (!jarg1) {
103158     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103159     return 0;
103160   }
103161   std::string arg1_str(jarg1);
103162   arg1 = &arg1_str;
103163   argp2 = (Dali::ImageDimensions *)jarg2;
103164   if (!argp2) {
103165     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103166     return 0;
103167   }
103168   arg2 = *argp2;
103169   arg3 = (Dali::FittingMode::Type)jarg3;
103170   arg4 = (Dali::SamplingMode::Type)jarg4;
103171   {
103172     try {
103173       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3,arg4);
103174     } catch (std::out_of_range& e) {
103175       {
103176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103177       };
103178     } catch (std::exception& e) {
103179       {
103180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103181       };
103182     } catch (...) {
103183       {
103184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103185       };
103186     }
103187   }
103188   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
103189
103190   return jresult;
103191 }
103192
103193
103194 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
103195   void * jresult ;
103196   std::string *arg1 = 0 ;
103197   Dali::ImageDimensions arg2 ;
103198   Dali::FittingMode::Type arg3 ;
103199   Dali::ImageDimensions *argp2 ;
103200   Dali::Devel::PixelBuffer result;
103201
103202   if (!jarg1) {
103203     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103204     return 0;
103205   }
103206   std::string arg1_str(jarg1);
103207   arg1 = &arg1_str;
103208   argp2 = (Dali::ImageDimensions *)jarg2;
103209   if (!argp2) {
103210     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103211     return 0;
103212   }
103213   arg2 = *argp2;
103214   arg3 = (Dali::FittingMode::Type)jarg3;
103215   {
103216     try {
103217       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3);
103218     } catch (std::out_of_range& e) {
103219       {
103220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103221       };
103222     } catch (std::exception& e) {
103223       {
103224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103225       };
103226     } catch (...) {
103227       {
103228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103229       };
103230     }
103231   }
103232   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
103233
103234   return jresult;
103235 }
103236
103237
103238 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_3(char * jarg1, void * jarg2) {
103239   void * jresult ;
103240   std::string *arg1 = 0 ;
103241   Dali::ImageDimensions arg2 ;
103242   Dali::ImageDimensions *argp2 ;
103243   Dali::Devel::PixelBuffer result;
103244
103245   if (!jarg1) {
103246     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103247     return 0;
103248   }
103249   std::string arg1_str(jarg1);
103250   arg1 = &arg1_str;
103251   argp2 = (Dali::ImageDimensions *)jarg2;
103252   if (!argp2) {
103253     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103254     return 0;
103255   }
103256   arg2 = *argp2;
103257   {
103258     try {
103259       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2);
103260     } catch (std::out_of_range& e) {
103261       {
103262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103263       };
103264     } catch (std::exception& e) {
103265       {
103266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103267       };
103268     } catch (...) {
103269       {
103270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103271       };
103272     }
103273   }
103274   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
103275
103276   return jresult;
103277 }
103278
103279
103280 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_4(char * jarg1) {
103281   void * jresult ;
103282   std::string *arg1 = 0 ;
103283   Dali::Devel::PixelBuffer result;
103284
103285   if (!jarg1) {
103286     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103287     return 0;
103288   }
103289   std::string arg1_str(jarg1);
103290   arg1 = &arg1_str;
103291   {
103292     try {
103293       result = Dali::DownloadImageSynchronously((std::string const &)*arg1);
103294     } catch (std::out_of_range& e) {
103295       {
103296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103297       };
103298     } catch (std::exception& e) {
103299       {
103300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103301       };
103302     } catch (...) {
103303       {
103304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103305       };
103306     }
103307   }
103308   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
103309
103310   return jresult;
103311 }
103312
103313
103314 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_New() {
103315   void * jresult ;
103316   Dali::Toolkit::WebView result;
103317
103318   {
103319     try {
103320       result = Dali::Toolkit::WebView::New();
103321     } catch (std::out_of_range& e) {
103322       {
103323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103324       };
103325     } catch (std::exception& e) {
103326       {
103327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103328       };
103329     } catch (Dali::DaliException e) {
103330       {
103331         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
103332       };
103333     } catch (...) {
103334       {
103335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103336       };
103337     }
103338   }
103339   jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView &)result);
103340   return jresult;
103341 }
103342
103343 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_New_2(char * jarg1, char * jarg2) {
103344   void * jresult ;
103345   Dali::Toolkit::WebView result;
103346
103347   std::string *arg1;
103348   std::string *arg2;
103349
103350   if (!jarg1) {
103351     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "jarg1 is null string", 0);
103352     return 0;
103353   }
103354   if (!jarg2) {
103355     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "jarg2 is null string", 0);
103356     return 0;
103357   }
103358
103359   std::string jarg1_str = std::string(jarg1);
103360   std::string jarg2_str = std::string(jarg2);
103361
103362   arg1 = &jarg1_str;
103363   arg2 = &jarg2_str;
103364
103365   {
103366     try {
103367       result = Dali::Toolkit::WebView::New( (std::string const &)*arg1, (std::string const &)*arg2);
103368     } catch (std::out_of_range& e) {
103369       {
103370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103371       };
103372     } catch (std::exception& e) {
103373       {
103374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103375       };
103376     } catch (Dali::DaliException e) {
103377       {
103378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
103379       };
103380     } catch (...) {
103381       {
103382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103383       };
103384     }
103385   }
103386   jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView &)result);
103387   return jresult;
103388 }
103389
103390 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebView__SWIG_1(void * jarg1) {
103391   void * jresult ;
103392   Dali::Toolkit::WebView *arg1 = 0 ;
103393   Dali::Toolkit::WebView *result = 0 ;
103394
103395   arg1 = (Dali::Toolkit::WebView *)jarg1;
103396   if (!arg1) {
103397     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::WebView const & type is null", 0);
103398     return 0;
103399   }
103400   {
103401     try {
103402       result = (Dali::Toolkit::WebView *)new Dali::Toolkit::WebView((Dali::Toolkit::WebView const &)*arg1);
103403     } catch (std::out_of_range& e) {
103404       {
103405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103406       };
103407     } catch (std::exception& e) {
103408       {
103409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103410       };
103411     } catch (Dali::DaliException e) {
103412       {
103413         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
103414       };
103415     } catch (...) {
103416       {
103417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103418       };
103419     }
103420   }
103421   jresult = (void *)result;
103422   return jresult;
103423 }
103424
103425 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebView(void * jarg1) {
103426   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103427   arg1 = (Dali::Toolkit::WebView *)jarg1;
103428   {
103429     try {
103430       delete arg1;
103431     } catch (std::out_of_range& e) {
103432       {
103433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103434       };
103435     } catch (std::exception& e) {
103436       {
103437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103438       };
103439     } catch (Dali::DaliException e) {
103440       {
103441         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103442       };
103443     } catch (...) {
103444       {
103445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103446       };
103447     }
103448   }
103449 }
103450
103451 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_Assign(void * jarg1, void * jarg2) {
103452   void * jresult ;
103453   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103454   Dali::Toolkit::WebView *arg2 = 0 ;
103455   Dali::Toolkit::WebView *result = 0 ;
103456
103457   arg1 = (Dali::Toolkit::WebView *)jarg1;
103458   arg2 = (Dali::Toolkit::WebView *)jarg2;
103459   if (!arg2) {
103460     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::WebView const & type is null", 0);
103461     return 0;
103462   }
103463   {
103464     try {
103465       result = (Dali::Toolkit::WebView *) &(arg1)->operator =((Dali::Toolkit::WebView const &)*arg2);
103466     } catch (std::out_of_range& e) {
103467       {
103468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103469       };
103470     } catch (std::exception& e) {
103471       {
103472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103473       };
103474     } catch (Dali::DaliException e) {
103475       {
103476         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
103477       };
103478     } catch (...) {
103479       {
103480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103481       };
103482     }
103483   }
103484   jresult = (void *)result;
103485   return jresult;
103486 }
103487
103488 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_DownCast(void * jarg1) {
103489   void * jresult ;
103490   Dali::BaseHandle arg1 ;
103491   Dali::BaseHandle *argp1 ;
103492   Dali::Toolkit::WebView result;
103493
103494   argp1 = (Dali::BaseHandle *)jarg1;
103495   if (!argp1) {
103496     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
103497     return 0;
103498   }
103499   arg1 = *argp1;
103500   {
103501     try {
103502       result = Dali::Toolkit::WebView::DownCast(arg1);
103503     } catch (std::out_of_range& e) {
103504       {
103505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103506       };
103507     } catch (std::exception& e) {
103508       {
103509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103510       };
103511     } catch (Dali::DaliException e) {
103512       {
103513         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
103514       };
103515     } catch (...) {
103516       {
103517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103518       };
103519     }
103520   }
103521   jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView &)result);
103522   return jresult;
103523 }
103524
103525 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_LoadUrl(void * jarg1, char * jarg2) {
103526   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103527   std::string *arg2;
103528
103529   arg1 = (Dali::Toolkit::WebView *)jarg1;
103530
103531   if (!jarg2) {
103532     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103533     return;
103534   }
103535
103536   std::string jarg2str = std::string(jarg2);
103537   arg2 = &jarg2str;
103538   {
103539     try {
103540       (arg1)->LoadUrl((std::string const &)*arg2);
103541     } catch (std::out_of_range& e) {
103542       {
103543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103544       };
103545     } catch (std::exception& e) {
103546       {
103547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103548       };
103549     } catch (Dali::DaliException e) {
103550       {
103551         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103552       };
103553     } catch (...) {
103554       {
103555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103556       };
103557     }
103558   }
103559 }
103560
103561 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_WebView_GetUrl(void * jarg1) {
103562   char * jresult ;
103563   std::string result;
103564
103565   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103566
103567   arg1 = (Dali::Toolkit::WebView *)jarg1;
103568   {
103569     try {
103570       result = arg1->GetUrl();
103571     } catch (std::out_of_range& e) {
103572       {
103573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103574       };
103575     } catch (std::exception& e) {
103576       {
103577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103578       };
103579     } catch (Dali::DaliException e) {
103580       {
103581         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
103582       };
103583     } catch (...) {
103584       {
103585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103586       };
103587     }
103588   }
103589
103590   jresult = SWIG_csharp_string_callback((&result)->c_str());
103591   return jresult;
103592 }
103593
103594 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_LoadHTMLString(void * jarg1, char * jarg2) {
103595   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103596   std::string *arg2;
103597
103598   arg1 = (Dali::Toolkit::WebView *)jarg1;
103599   if (!jarg2) {
103600     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103601     return;
103602   }
103603   std::string jarg2str = std::string(jarg2);
103604   arg2 = &jarg2str;
103605   {
103606     try {
103607       (arg1)->LoadHTMLString((std::string const &)*arg2);
103608     } catch (std::out_of_range& e) {
103609       {
103610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103611       };
103612     } catch (std::exception& e) {
103613       {
103614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103615       };
103616     } catch (Dali::DaliException e) {
103617       {
103618         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103619       };
103620     } catch (...) {
103621       {
103622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103623       };
103624     }
103625   }
103626 }
103627
103628 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_Reload(void * jarg1) {
103629   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103630
103631   arg1 = (Dali::Toolkit::WebView *)jarg1;
103632   {
103633     try {
103634       (arg1)->Reload();
103635     } catch (std::out_of_range& e) {
103636       {
103637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103638       };
103639     } catch (std::exception& e) {
103640       {
103641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103642       };
103643     } catch (Dali::DaliException e) {
103644       {
103645         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103646       };
103647     } catch (...) {
103648       {
103649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103650       };
103651     }
103652   }
103653 }
103654
103655 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_StopLoading(void * jarg1) {
103656   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103657
103658   arg1 = (Dali::Toolkit::WebView *)jarg1;
103659   {
103660     try {
103661       (arg1)->StopLoading();
103662     } catch (std::out_of_range& e) {
103663       {
103664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103665       };
103666     } catch (std::exception& e) {
103667       {
103668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103669       };
103670     } catch (Dali::DaliException e) {
103671       {
103672         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103673       };
103674     } catch (...) {
103675       {
103676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103677       };
103678     }
103679   }
103680 }
103681
103682 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_GoBack(void * jarg1) {
103683   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103684
103685   arg1 = (Dali::Toolkit::WebView *)jarg1;
103686   {
103687     try {
103688       (arg1)->GoBack();
103689     } catch (std::out_of_range& e) {
103690       {
103691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103692       };
103693     } catch (std::exception& e) {
103694       {
103695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103696       };
103697     } catch (Dali::DaliException e) {
103698       {
103699         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103700       };
103701     } catch (...) {
103702       {
103703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103704       };
103705     }
103706   }
103707 }
103708
103709 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_GoForward(void * jarg1) {
103710   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103711
103712   arg1 = (Dali::Toolkit::WebView *)jarg1;
103713   {
103714     try {
103715       (arg1)->GoForward();
103716     } catch (std::out_of_range& e) {
103717       {
103718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103719       };
103720     } catch (std::exception& e) {
103721       {
103722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103723       };
103724     } catch (Dali::DaliException e) {
103725       {
103726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103727       };
103728     } catch (...) {
103729       {
103730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103731       };
103732     }
103733   }
103734 }
103735
103736 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebView_CanGoBack(void * jarg1) {
103737   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103738   bool ret;
103739
103740   arg1 = (Dali::Toolkit::WebView *)jarg1;
103741   {
103742     try {
103743       ret = (arg1)->CanGoBack();
103744     } catch (std::out_of_range& e) {
103745       {
103746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return false;
103747       };
103748     } catch (std::exception& e) {
103749       {
103750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return false;
103751       };
103752     } catch (Dali::DaliException e) {
103753       {
103754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return false;
103755       };
103756     } catch (...) {
103757       {
103758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return false;
103759       };
103760     }
103761   }
103762   return ret;
103763 }
103764
103765 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebView_CanGoForward(void * jarg1) {
103766   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103767   bool ret;
103768
103769   arg1 = (Dali::Toolkit::WebView *)jarg1;
103770   {
103771     try {
103772       ret = (arg1)->CanGoForward();
103773     } catch (std::out_of_range& e) {
103774       {
103775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return false;
103776       };
103777     } catch (std::exception& e) {
103778       {
103779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return false;
103780       };
103781     } catch (Dali::DaliException e) {
103782       {
103783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return false;
103784       };
103785     } catch (...) {
103786       {
103787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return false;
103788       };
103789     }
103790   }
103791   return ret;
103792 }
103793
103794 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_EvaluateJavaScript(void * jarg1, char * jarg2) {
103795   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103796   std::string *arg2;
103797
103798   arg1 = (Dali::Toolkit::WebView *)jarg1;
103799   if (!jarg2) {
103800     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103801     return;
103802   }
103803   std::string jarg2_str = std::string(jarg2);
103804   arg2 = &jarg2_str;
103805   {
103806     try {
103807       (arg1)->EvaluateJavaScript((std::string const &)*arg2);
103808     } catch (std::out_of_range& e) {
103809       {
103810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103811       };
103812     } catch (std::exception& e) {
103813       {
103814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103815       };
103816     } catch (Dali::DaliException e) {
103817       {
103818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103819       };
103820     } catch (...) {
103821       {
103822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103823       };
103824     }
103825   }
103826 }
103827
103828 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_AddJavaScriptMessageHandler(void* jarg1, char* jarg2, void* jarg3)
103829 {
103830   if (!jarg2) {
103831     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103832     return;
103833   }
103834
103835   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
103836   std::string exposedObjectName = jarg2;
103837   void (*handler)(char*) = (void (*)(char*)) jarg3;
103838
103839   {
103840     try {
103841       webview->AddJavaScriptMessageHandler(exposedObjectName, [handler](const std::string& message) {
103842         handler(SWIG_csharp_string_callback(message.c_str()));
103843       });
103844     } catch (std::out_of_range& e) {
103845       {
103846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103847       };
103848     } catch (std::exception& e) {
103849       {
103850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103851       };
103852     } catch (Dali::DaliException e) {
103853       {
103854         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103855       };
103856     } catch (...) {
103857       {
103858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103859       };
103860     }
103861   }
103862 }
103863
103864 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ClearHistory(void * jarg1) {
103865   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103866
103867   arg1 = (Dali::Toolkit::WebView *)jarg1;
103868   {
103869     try {
103870       (arg1)->ClearHistory();
103871     } catch (std::out_of_range& e) {
103872       {
103873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103874       };
103875     } catch (std::exception& e) {
103876       {
103877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103878       };
103879     } catch (Dali::DaliException e) {
103880       {
103881         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103882       };
103883     } catch (...) {
103884       {
103885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103886       };
103887     }
103888   }
103889 }
103890
103891 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ClearCache(void * jarg1) {
103892   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103893
103894   arg1 = (Dali::Toolkit::WebView *)jarg1;
103895   {
103896     try {
103897       (arg1)->ClearCache();
103898     } catch (std::out_of_range& e) {
103899       {
103900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103901       };
103902     } catch (std::exception& e) {
103903       {
103904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103905       };
103906     } catch (Dali::DaliException e) {
103907       {
103908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103909       };
103910     } catch (...) {
103911       {
103912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103913       };
103914     }
103915   }
103916 }
103917
103918 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_WebView_SWIGUpcast(Dali::Toolkit::WebView *jarg1) {
103919     return (Dali::Toolkit::Control *)jarg1;
103920 }
103921
103922
103923 // Proxy class of WebViewSignal.
103924 // WebViewSignal has an argument of std::string type which is not supported at C# side.
103925 // The purpose of this class is to convert signal argument of string type safely.
103926 class WebViewSignalProxy : public ConnectionTracker
103927 {
103928 public:
103929   typedef Dali::Signal< void(Dali::Toolkit::WebView, const std::string&) > OriginalSignalType;
103930   typedef Dali::Signal< void(Dali::Toolkit::WebView, char*) > ProxySignalType;
103931   typedef void (*CallbackType)(Dali::Toolkit::WebView, char *);
103932
103933   WebViewSignalProxy(OriginalSignalType* signal)
103934     : mSignalPtr(signal)
103935   {
103936   }
103937
103938   void Connect(CallbackType csharpCallback)
103939   {
103940     if (mSignalPtr->Empty())
103941     {
103942       mSignalPtr->Connect(this, &WebViewSignalProxy::OnEmit);
103943     }
103944     mProxySignal.Connect(csharpCallback);
103945   }
103946
103947   void Disconnect(CallbackType csharpCallback)
103948   {
103949     mProxySignal.Disconnect(csharpCallback);
103950     if (mProxySignal.Empty())
103951     {
103952       mSignalPtr->Disconnect(this, &WebViewSignalProxy::OnEmit);
103953     }
103954   }
103955
103956   bool Empty()
103957   {
103958     return mProxySignal.Empty();
103959   }
103960
103961   std::size_t GetConnectionCount()
103962   {
103963     return mProxySignal.GetConnectionCount();
103964   }
103965
103966   void Emit(Dali::Toolkit::WebView& webview, char* url)
103967   {
103968     if (!mProxySignal.Empty())
103969     {
103970       mProxySignal.Emit(webview, url);
103971     }
103972   }
103973
103974   void OnEmit(Dali::Toolkit::WebView webview, const std::string& url)
103975   {
103976     // Safe string conversion
103977     mProxySignal.Emit(webview, SWIG_csharp_string_callback(url.c_str()));
103978   }
103979
103980 private:
103981   OriginalSignalType* mSignalPtr;
103982   ProxySignalType mProxySignal;
103983 };
103984
103985 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebViewSignalProxy_PageLoadStarted(void * jarg1) {
103986   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
103987   WebViewSignalProxy* result = NULL;
103988   {
103989     try {
103990       result = new WebViewSignalProxy(&webview->PageLoadStartedSignal());
103991     } catch (std::out_of_range& e) {
103992       {
103993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103994       };
103995     } catch (std::exception& e) {
103996       {
103997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103998       };
103999     } catch (Dali::DaliException e) {
104000       {
104001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
104002       };
104003     } catch (...) {
104004       {
104005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
104006       };
104007     }
104008   }
104009   return (void*) result;
104010 }
104011
104012 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebViewSignalProxy_PageLoadFinished(void * jarg1) {
104013   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
104014   WebViewSignalProxy* result = NULL;
104015   {
104016     try {
104017       result = new WebViewSignalProxy(&webview->PageLoadFinishedSignal());
104018     } catch (std::out_of_range& e) {
104019       {
104020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
104021       };
104022     } catch (std::exception& e) {
104023       {
104024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
104025       };
104026     } catch (Dali::DaliException e) {
104027       {
104028         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
104029       };
104030     } catch (...) {
104031       {
104032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
104033       };
104034     }
104035   }
104036   return (void*) result;
104037 }
104038
104039 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebViewSignalProxy(void * jarg1)
104040 {
104041   WebViewSignalProxy* object = (WebViewSignalProxy*) jarg1;
104042   {
104043     try {
104044       delete object;
104045     } catch (std::out_of_range& e) {
104046       {
104047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
104048       };
104049     } catch (std::exception& e) {
104050       {
104051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
104052       };
104053     } catch (Dali::DaliException e) {
104054       {
104055         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
104056       };
104057     } catch (...) {
104058       {
104059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
104060       };
104061     }
104062   }
104063 }
104064
104065 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_WebViewSignalProxy_Empty(void * jarg1)
104066 {
104067   bool result;
104068   WebViewSignalProxy* proxy = (WebViewSignalProxy*) jarg1;
104069   {
104070     try {
104071       result = (bool)proxy->Empty();
104072     } catch (std::out_of_range& e) {
104073       {
104074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
104075       };
104076     } catch (std::exception& e) {
104077       {
104078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
104079       };
104080     } catch (Dali::DaliException e) {
104081       {
104082         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
104083       };
104084     } catch (...) {
104085       {
104086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
104087       };
104088     }
104089   }
104090   return (unsigned int) result;
104091 }
104092
104093
104094 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_WebViewSignalProxy_GetConnectionCount(void * jarg1)
104095 {
104096   std::size_t result;
104097   WebViewSignalProxy* arg1 = (WebViewSignalProxy*) jarg1;
104098   {
104099     try {
104100       result = arg1->GetConnectionCount();
104101     } catch (std::out_of_range& e) {
104102       {
104103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
104104       };
104105     } catch (std::exception& e) {
104106       {
104107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
104108       };
104109     } catch (Dali::DaliException e) {
104110       {
104111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
104112       };
104113     } catch (...) {
104114       {
104115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
104116       };
104117     }
104118   }
104119   return (unsigned long) result;
104120 }
104121
104122 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewSignalProxy_Connect(void * jarg1, void * jarg2)
104123 {
104124   WebViewSignalProxy* proxy = (WebViewSignalProxy*) jarg1;
104125   WebViewSignalProxy::CallbackType callback = (WebViewSignalProxy::CallbackType) jarg2;
104126   {
104127     try {
104128       proxy->Connect(callback);
104129     } catch (std::out_of_range& e) {
104130       {
104131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
104132       };
104133     } catch (std::exception& e) {
104134       {
104135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
104136       };
104137     } catch (Dali::DaliException e) {
104138       {
104139         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
104140       };
104141     } catch (...) {
104142       {
104143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
104144       };
104145     }
104146   }
104147 }
104148
104149
104150 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewSignalProxy_Disconnect(void * jarg1, void * jarg2) {
104151   WebViewSignalProxy* proxy = (WebViewSignalProxy*) jarg1;
104152   WebViewSignalProxy::CallbackType callback = (WebViewSignalProxy::CallbackType) jarg2;
104153   {
104154     try {
104155       proxy->Disconnect(callback);
104156     } catch (std::out_of_range& e) {
104157       {
104158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
104159       };
104160     } catch (std::exception& e) {
104161       {
104162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
104163       };
104164     } catch (Dali::DaliException e) {
104165       {
104166         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
104167       };
104168     } catch (...) {
104169       {
104170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
104171       };
104172     }
104173   }
104174 }
104175
104176
104177 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewSignalProxy_Emit(void * jarg1, void * jarg2, char * jarg3) {
104178   if (!jarg2) {
104179     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::WebView & type is null", 0);
104180     return ;
104181   }
104182   if (!jarg3) {
104183     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "jarg3 is null string", 0);
104184     return ;
104185   }
104186
104187   WebViewSignalProxy* proxy = (WebViewSignalProxy*) jarg1;
104188   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView*) jarg2;
104189   {
104190     try {
104191       proxy->Emit(*webview, jarg3);
104192     } catch (std::out_of_range& e) {
104193       {
104194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
104195       };
104196     } catch (std::exception& e) {
104197       {
104198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
104199       };
104200     } catch (Dali::DaliException e) {
104201       {
104202         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
104203       };
104204     } catch (...) {
104205       {
104206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
104207       };
104208     }
104209   }
104210 }
104211
104212 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetEnvironmentVariable(char * jarg1) {
104213   const char * result = EnvironmentVariable::GetEnvironmentVariable(jarg1);
104214   char * jresult = SWIG_csharp_string_callback((const char *)result);
104215   return jresult;
104216 }
104217
104218 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_SetEnvironmentVariable(char * jarg1, char * jarg2) {
104219   bool result = EnvironmentVariable::SetEnvironmentVariable(jarg1, jarg2);
104220   return result;
104221 }
104222
104223 #ifdef __cplusplus
104224 }
104225 #endif
104226